These are all on GtkBox or enumerating children.
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_widget_set_hexpand (label, TRUE);
gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
if (GTK_IS_CONSTRAINT (item) || GTK_IS_CONSTRAINT_GUIDE (item))
{
gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (row_edit), win);
g_object_set_data (G_OBJECT (row), "edit", button);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_from_icon_name ("edit-delete-symbolic");
gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (row_delete), win);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
}
else if (GTK_IS_WIDGET (item))
{
button = gtk_button_new_from_icon_name ("edit-delete-symbolic");
gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (row_delete), win);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
}
g_free (freeme);
gtk_widget_set_margin_bottom (box, 12);
label = gtk_label_new ("You must fill out this entry to continue:");
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_widget_set_valign (entry, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), entry);
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (on_entry_changed), assistant);
checkbutton = gtk_check_button_new_with_label ("This is optional data, you may continue "
"even if you do not check this");
gtk_widget_set_valign (checkbutton, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (box), checkbutton);
+ gtk_box_append (GTK_BOX (box), checkbutton);
gtk_assistant_append_page (GTK_ASSISTANT (assistant), box);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), box, TRUE);
label = gtk_label_new ("\"Copy\" will copy the text\nin the entry to the clipboard");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_widget_set_margin_start (hbox, 8);
gtk_widget_set_margin_end (hbox, 8);
gtk_widget_set_margin_top (hbox, 8);
gtk_widget_set_margin_bottom (hbox, 8);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
/* Create the first entry */
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (hbox), entry);
/* Create the button */
button = gtk_button_new_with_mnemonic (_("_Copy"));
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (copy_button_clicked), entry);
label = gtk_label_new ("\"Paste\" will paste the text from the clipboard to the entry");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_widget_set_margin_start (hbox, 8);
gtk_widget_set_margin_end (hbox, 8);
gtk_widget_set_margin_top (hbox, 8);
gtk_widget_set_margin_bottom (hbox, 8);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
/* Create the second entry */
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (hbox), entry);
/* Create the button */
button = gtk_button_new_with_mnemonic (_("_Paste"));
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (paste_button_clicked), entry);
label = gtk_label_new ("Images can be transferred via the clipboard, too");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_widget_set_margin_start (hbox, 8);
gtk_widget_set_margin_end (hbox, 8);
gtk_widget_set_margin_top (hbox, 8);
gtk_widget_set_margin_bottom (hbox, 8);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
/* Create the first image */
image = demo_image_new ("dialog-warning");
- gtk_container_add (GTK_CONTAINER (hbox), image);
+ gtk_box_append (GTK_BOX (hbox), image);
/* Create the second image */
image = demo_image_new ("process-stop");
- gtk_container_add (GTK_CONTAINER (hbox), image);
+ gtk_box_append (GTK_BOX (hbox), image);
/* Create the third image */
image = demo_image_new ("weather-clear");
- gtk_container_add (GTK_CONTAINER (hbox), image);
+ gtk_box_append (GTK_BOX (hbox), image);
}
if (!gtk_widget_get_visible (window))
* insensitive rows
*/
frame = gtk_frame_new ("Items with icons");
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_margin_start (box, 5);
model = create_icon_store ();
combo = gtk_combo_box_new_with_model (model);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
/* A combobox demonstrating trees.
*/
frame = gtk_frame_new ("Where are we ?");
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_margin_start (box, 5);
model = create_capital_store ();
combo = gtk_combo_box_new_with_model (model);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
/* A GtkComboBoxEntry with validation */
frame = gtk_frame_new ("Editable");
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_margin_start (box, 5);
combo = gtk_combo_box_text_new_with_entry ();
fill_combo_entry (combo);
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
entry = g_object_new (TYPE_MASK_ENTRY, NULL);
MASK_ENTRY (entry)->mask = "^([0-9]*|One|Two|2\302\275|Three)$";
/* A combobox with string IDs */
frame = gtk_frame_new ("String IDs");
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_margin_start (box, 5);
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "never", "Not visible");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "when-active", "Visible when active");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "always", "Always visible");
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
entry = gtk_entry_new ();
g_object_bind_property (combo, "active-id",
entry, "text",
G_BINDING_BIDIRECTIONAL);
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), entry);
}
if (!gtk_widget_get_visible (window))
grid = g_object_new (simple_grid_get_type (), NULL);
gtk_widget_set_hexpand (grid, TRUE);
gtk_widget_set_vexpand (grid, TRUE);
- gtk_container_add (GTK_CONTAINER (box), grid);
+ gtk_box_append (GTK_BOX (box), grid);
button = gtk_button_new_with_label ("Close");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
gtk_widget_set_hexpand (grid, TRUE);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy), window);
grid = g_object_new (interactive_grid_get_type (), NULL);
gtk_widget_set_hexpand (grid, TRUE);
gtk_widget_set_vexpand (grid, TRUE);
- gtk_container_add (GTK_CONTAINER (box), grid);
+ gtk_box_append (GTK_BOX (box), grid);
button = gtk_button_new_with_label ("Close");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
gtk_widget_set_hexpand (grid, TRUE);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy), window);
grid = g_object_new (vfl_grid_get_type (), NULL);
gtk_widget_set_hexpand (grid, TRUE);
gtk_widget_set_vexpand (grid, TRUE);
- gtk_container_add (GTK_CONTAINER (box), grid);
+ gtk_box_append (GTK_BOX (box), grid);
button = gtk_button_new_with_label ("Close");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
gtk_widget_set_hexpand (grid, TRUE);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy), window);
static void
apply_css (GtkWidget *widget, GtkStyleProvider *provider)
{
+ GtkWidget *child;
+
gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
- if (GTK_IS_CONTAINER (widget))
- gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
+ for (child = gtk_widget_get_first_child (widget);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ apply_css (child, provider);
}
GtkWidget *
gtk_window_set_child (GTK_WINDOW (window), container);
child = gtk_button_new_with_label ("This");
- gtk_container_add (GTK_CONTAINER (container), child);
+ gtk_box_append (GTK_BOX (container), child);
child = gtk_button_new_with_label ("Is");
- gtk_container_add (GTK_CONTAINER (container), child);
+ gtk_box_append (GTK_BOX (container), child);
child = gtk_button_new_with_label ("A");
- gtk_container_add (GTK_CONTAINER (container), child);
+ gtk_box_append (GTK_BOX (container), child);
child = gtk_button_new_with_label ("CSS");
- gtk_container_add (GTK_CONTAINER (container), child);
+ gtk_box_append (GTK_BOX (container), child);
child = gtk_button_new_with_label ("Accordion");
- gtk_container_add (GTK_CONTAINER (container), child);
+ gtk_box_append (GTK_BOX (container), child);
child = gtk_button_new_with_label (":-)");
- gtk_container_add (GTK_CONTAINER (container), child);
+ gtk_box_append (GTK_BOX (container), child);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
gtk_css_provider_load_from_resource (GTK_CSS_PROVIDER (provider), "/css_accordion/css_accordion.css");
static void
apply_css (GtkWidget *widget, GtkStyleProvider *provider)
{
+ GtkWidget *child;
+
gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
- if (GTK_IS_CONTAINER (widget))
- gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
+ for (child = gtk_widget_get_first_child (widget);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ apply_css (child, provider);
}
GtkWidget *
container = gtk_scrolled_window_new (NULL, NULL);
gtk_window_set_child (GTK_WINDOW (window), container);
child = gtk_text_view_new_with_buffer (text);
- gtk_container_add (GTK_CONTAINER (container), child);
+ gtk_box_append (GTK_BOX (container), child);
g_signal_connect (text, "changed",
G_CALLBACK (css_text_changed), provider);
static void
apply_css (GtkWidget *widget, GtkStyleProvider *provider)
{
+ GtkWidget *child;
+
gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
- if (GTK_IS_CONTAINER (widget))
- gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
+ for (child = gtk_widget_get_first_child (widget);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ apply_css (child, provider);
}
GtkWidget *
gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (child),
drawing_area_draw,
NULL, NULL);
- gtk_container_add (GTK_CONTAINER (container), child);
+ gtk_box_append (GTK_BOX (container), child);
child = gtk_button_new ();
gtk_overlay_add_overlay (GTK_OVERLAY (container), child);
static void
apply_css (GtkWidget *widget, GtkStyleProvider *provider)
{
+ GtkWidget *child;
+
gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
- if (GTK_IS_CONTAINER (widget))
- gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
+ for (child = gtk_widget_get_first_child (widget);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ apply_css (child, provider);
}
GtkWidget *
static void
apply_css (GtkWidget *widget, GtkStyleProvider *provider)
{
+ GtkWidget *child;
+
gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
- if (GTK_IS_CONTAINER (widget))
- gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
+ for (child = gtk_widget_get_first_child (widget);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ apply_css (child, provider);
}
static GtkWidget *
gtk_widget_set_valign (toolbar, GTK_ALIGN_CENTER);
item = gtk_button_new_from_icon_name ("go-next");
- gtk_container_add (GTK_CONTAINER (toolbar), item);
+ gtk_box_append (GTK_BOX (toolbar), item);
item = gtk_button_new_from_icon_name ("go-previous");
- gtk_container_add (GTK_CONTAINER (toolbar), item);
+ gtk_box_append (GTK_BOX (toolbar), item);
item = gtk_button_new_with_label ("Hello World");
- gtk_container_add (GTK_CONTAINER (toolbar), item);
+ gtk_box_append (GTK_BOX (toolbar), item);
return toolbar;
}
gtk_widget_set_vexpand (priv->entry, TRUE);
gtk_widget_set_hexpand (priv->box, FALSE);
gtk_widget_set_vexpand (priv->box, FALSE);
- gtk_container_add (GTK_CONTAINER (priv->box), priv->entry);
+ gtk_box_append (GTK_BOX (priv->box), priv->entry);
gtk_editable_init_delegate (GTK_EDITABLE (entry));
}
g_return_if_fail (DEMO_IS_TAGGED_ENTRY (entry));
- gtk_container_add (GTK_CONTAINER (priv->box), tag);
+ gtk_box_append (GTK_BOX (priv->box), tag);
}
void
g_return_if_fail (DEMO_IS_TAGGED_ENTRY (entry));
if (sibling == NULL)
- gtk_container_add (GTK_CONTAINER (priv->box), tag);
+ gtk_box_append (GTK_BOX (priv->box), tag);
else
gtk_box_insert_child_after (GTK_BOX (priv->box), tag, sibling);
}
g_return_if_fail (DEMO_IS_TAGGED_ENTRY (entry));
- gtk_container_remove (GTK_CONTAINER (priv->box), tag);
+ gtk_box_remove (GTK_BOX (priv->box), tag);
}
struct _DemoTaggedEntryTag
tag->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_parent (tag->box, GTK_WIDGET (tag));
tag->label = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (tag->box), tag->label);
+ gtk_box_append (GTK_BOX (tag->box), tag->label);
gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "released", G_CALLBACK (on_released), tag);
if (!has_close_button && tag->button)
{
- gtk_container_remove (GTK_CONTAINER (tag->box), tag->button);
+ gtk_box_remove (GTK_BOX (tag->box), tag->button);
tag->button = NULL;
}
else if (has_close_button && tag->button == NULL)
image = gtk_image_new_from_icon_name ("window-close-symbolic");
tag->button = gtk_button_new ();
- gtk_container_add (GTK_CONTAINER (tag->button), image);
+ gtk_box_append (GTK_BOX (tag->button), image);
gtk_widget_set_halign (tag->button, GTK_ALIGN_CENTER);
gtk_widget_set_valign (tag->button, GTK_ALIGN_CENTER);
gtk_button_set_has_frame (GTK_BUTTON (tag->button), FALSE);
- gtk_container_add (GTK_CONTAINER (tag->box), tag->button);
+ gtk_box_append (GTK_BOX (tag->box), tag->button);
g_signal_connect (tag->button, "clicked", G_CALLBACK (on_button_clicked), tag);
}
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
- gtk_container_add (GTK_CONTAINER (content_area), hbox);
+ gtk_box_append (GTK_BOX (content_area), hbox);
image = gtk_image_new_from_icon_name ("dialog-question");
gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
- gtk_container_add (GTK_CONTAINER (hbox), image);
+ gtk_box_append (GTK_BOX (hbox), image);
table = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (table), 4);
gtk_grid_set_column_spacing (GTK_GRID (table), 4);
- gtk_container_add (GTK_CONTAINER (hbox), table);
+ gtk_box_append (GTK_BOX (hbox), table);
label = gtk_label_new_with_mnemonic ("_Entry 1");
gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);
local_entry1 = gtk_entry_new ();
/* Standard message dialog */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_button_new_with_mnemonic ("_Message Dialog");
g_signal_connect (button, "clicked",
G_CALLBACK (message_dialog_clicked), NULL);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
/* Interactive dialog*/
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
button = gtk_button_new_with_mnemonic ("_Interactive Dialog");
g_signal_connect (button, "clicked",
G_CALLBACK (interactive_dialog_clicked), NULL);
- gtk_container_add (GTK_CONTAINER (hbox), vbox2);
- gtk_container_add (GTK_CONTAINER (vbox2), button);
+ gtk_box_append (GTK_BOX (hbox), vbox2);
+ gtk_box_append (GTK_BOX (vbox2), button);
table = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (table), 4);
gtk_grid_set_column_spacing (GTK_GRID (table), 4);
- gtk_container_add (GTK_CONTAINER (hbox), table);
+ gtk_box_append (GTK_BOX (hbox), table);
label = gtk_label_new_with_mnemonic ("_Entry 1");
gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);
gtk_popover_set_has_arrow (GTK_POPOVER (menu), FALSE);
gtk_popover_set_pointing_to (GTK_POPOVER (menu), &(GdkRectangle){ x, y, 1, 1});
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (menu), box);
+ gtk_box_append (GTK_BOX (menu), box);
item = gtk_button_new_with_label ("New");
gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
g_signal_connect (item, "clicked", G_CALLBACK (new_item_cb), widget);
- gtk_container_add (GTK_CONTAINER (box), item);
+ gtk_box_append (GTK_BOX (box), item);
item = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box), item);
+ gtk_box_append (GTK_BOX (box), item);
item = gtk_button_new_with_label ("Edit");
gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
gtk_widget_set_sensitive (item, child != NULL && child != widget);
g_signal_connect (item, "clicked", G_CALLBACK (edit_cb), child);
- gtk_container_add (GTK_CONTAINER (box), item);
+ gtk_box_append (GTK_BOX (box), item);
item = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box), item);
+ gtk_box_append (GTK_BOX (box), item);
item = gtk_button_new_with_label ("Delete");
gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
gtk_widget_set_sensitive (item, child != NULL && child != widget);
g_signal_connect (item, "clicked", G_CALLBACK (delete_cb), child);
- gtk_container_add (GTK_CONTAINER (box), item);
+ gtk_box_append (GTK_BOX (box), item);
gtk_popover_popup (GTK_POPOVER (menu));
}
gtk_window_set_child (GTK_WINDOW (window), box);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), box2);
+ gtk_box_append (GTK_BOX (box), box2);
canvas = canvas_new ();
- gtk_container_add (GTK_CONTAINER (box2), canvas);
+ gtk_box_append (GTK_BOX (box2), canvas);
n_items = 0;
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_NEVER);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_add_css_class (box3, "linked");
"rgba", &rgba,
"selectable", FALSE,
NULL);
- gtk_container_add (GTK_CONTAINER (box3), swatch);
+ gtk_box_append (GTK_BOX (box3), swatch);
}
}
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Checkerboard pattern</u>");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
frame = gtk_frame_new (NULL);
gtk_widget_set_vexpand (frame, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
da = gtk_drawing_area_new ();
gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (da), 100);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Scribble area</u>");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
frame = gtk_frame_new (NULL);
gtk_widget_set_vexpand (frame, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
da = gtk_drawing_area_new ();
gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (da), 100);
gtk_widget_set_margin_bottom (vbox, 5);
gtk_window_set_child (GTK_WINDOW (window), vbox);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Shopping list (you can edit the cells!)"));
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (vbox), sw);
+ gtk_box_append (GTK_BOX (vbox), sw);
/* create models */
items_model = create_items_model ();
/* some buttons */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_button_new_with_label ("Add item");
g_signal_connect (button, "clicked",
G_CALLBACK (add_item), treeview);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_button_new_with_label ("Remove item");
g_signal_connect (button, "clicked",
G_CALLBACK (remove_item), treeview);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
gtk_window_set_default_size (GTK_WINDOW (window), 320, 200);
}
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "Completion demo, try writing <b>total</b> or <b>gnome</b> for example.");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
/* Create our entry */
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (vbox), entry);
+ gtk_box_append (GTK_BOX (vbox), entry);
/* Create the completion object */
completion = gtk_entry_completion_new ();
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"Use Primary+z or Primary+Shift+z to undo or redo changes");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
/* Create our entry */
entry = gtk_entry_new ();
gtk_editable_set_enable_undo (GTK_EDITABLE (entry), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), entry);
+ gtk_box_append (GTK_BOX (vbox), entry);
}
if (!gtk_widget_get_visible (window))
"innuendo, just to make you scroll down or "
"resize the window. Do it already !", -1);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), tv);
- gtk_container_add (GTK_CONTAINER (expander), sw);
- gtk_container_add (GTK_CONTAINER (area), expander);
+ gtk_box_append (GTK_BOX (expander), sw);
+ gtk_box_append (GTK_BOX (area), expander);
g_signal_connect (expander, "notify::expanded",
G_CALLBACK (expander_cb), window);
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
- gtk_container_add (GTK_CONTAINER (group), label);
+ gtk_box_append (GTK_BOX (group), label);
for (i = 0; tags[i]; i++)
{
g_signal_connect (feat, "notify::inconsistent", G_CALLBACK (update_display), NULL);
g_signal_connect (feat, "clicked", G_CALLBACK (feat_clicked), NULL);
- gtk_container_add (GTK_CONTAINER (group), feat);
+ gtk_box_append (GTK_BOX (group), feat);
item = g_new (FeatureItem, 1);
item->name = tags[i];
feature_items = g_list_prepend (feature_items, item);
}
- gtk_container_add (GTK_CONTAINER (box), group);
+ gtk_box_append (GTK_BOX (box), group);
}
static void
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
- gtk_container_add (GTK_CONTAINER (group), label);
+ gtk_box_append (GTK_BOX (group), label);
for (i = 0; tags[i]; i++)
{
g_signal_connect (feat, "notify::active", G_CALLBACK (update_display), NULL);
g_object_set_data (G_OBJECT (feat), "default", group_button);
- gtk_container_add (GTK_CONTAINER (group), feat);
+ gtk_box_append (GTK_BOX (group), feat);
item = g_new (FeatureItem, 1);
item->name = tags[i];
feature_items = g_list_prepend (feature_items, item);
}
- gtk_container_add (GTK_CONTAINER (box), group);
+ gtk_box_append (GTK_BOX (box), group);
}
static void
}
label = gtk_label_new (text);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
gtk_widget_show (label);
adj = gtk_adjustment_new (gtk_gears_get_axis (gears, axis), 0.0, 360.0, 1.0, 12.0, 0.0);
gears);
slider = gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj);
gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
- gtk_container_add (GTK_CONTAINER (box), slider);
+ gtk_box_append (GTK_BOX (box), slider);
gtk_widget_set_vexpand (slider, TRUE);
gtk_widget_show (slider);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
gtk_box_set_spacing (GTK_BOX (box), 6);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
gears = gtk_gears_new ();
gtk_widget_set_hexpand (gears, TRUE);
gtk_widget_set_vexpand (gears, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), gears);
+ gtk_box_append (GTK_BOX (hbox), gears);
for (i = 0; i < GTK_GEARS_N_AXIS; i++)
- gtk_container_add (GTK_CONTAINER (hbox), create_axis_slider (GTK_GEARS (gears), i));
+ gtk_box_append (GTK_BOX (hbox), create_axis_slider (GTK_GEARS (gears), i));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
gtk_box_set_spacing (GTK_BOX (hbox), 6);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
gtk_gears_set_fps_label (GTK_GEARS (gears), GTK_LABEL (fps_label));
}
}
label = gtk_label_new (text);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
gtk_widget_show (label);
adj = gtk_adjustment_new (0.0, 0.0, 360.0, 1.0, 12.0, 0.0);
G_CALLBACK (on_axis_value_change),
GINT_TO_POINTER (axis));
slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adj);
- gtk_container_add (GTK_CONTAINER (box), slider);
+ gtk_box_append (GTK_BOX (box), slider);
gtk_widget_set_hexpand (slider, TRUE);
gtk_widget_show (slider);
gl_area = gtk_gl_area_new ();
gtk_widget_set_hexpand (gl_area, TRUE);
gtk_widget_set_vexpand (gl_area, TRUE);
- gtk_container_add (GTK_CONTAINER (box), gl_area);
+ gtk_box_append (GTK_BOX (box), gl_area);
/* We need to initialize and free GL resources, so we use
* the realize and unrealize signals on the widget
g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
controls = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE);
- gtk_container_add (GTK_CONTAINER (box), controls);
+ gtk_box_append (GTK_BOX (box), controls);
gtk_widget_set_hexpand (controls, TRUE);
for (i = 0; i < N_AXIS; i++)
- gtk_container_add (GTK_CONTAINER (controls), create_axis_slider (i));
+ gtk_box_append (GTK_BOX (controls), create_axis_slider (i));
button = gtk_button_new_with_label ("Quit");
gtk_widget_set_hexpand (button, TRUE);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
return window;
gtk_widget_add_css_class (box, "linked");
button = gtk_button_new ();
gtk_button_set_child (GTK_BUTTON (button), gtk_image_new_from_icon_name ("pan-start-symbolic"));
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new ();
gtk_button_set_child (GTK_BUTTON (button), gtk_image_new_from_icon_name ("pan-end-symbolic"));
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
gtk_header_bar_pack_start (GTK_HEADER_BAR (header), box);
gtk_window_set_child (GTK_WINDOW (window), vbox);
tool_bar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), tool_bar);
+ gtk_box_append (GTK_BOX (vbox), tool_bar);
up_button = gtk_button_new_with_mnemonic ("_Up");
gtk_widget_set_sensitive (GTK_WIDGET (up_button), FALSE);
- gtk_container_add (GTK_CONTAINER (tool_bar), up_button);
+ gtk_box_append (GTK_BOX (tool_bar), up_button);
home_button = gtk_button_new_with_mnemonic ("_Home");
- gtk_container_add (GTK_CONTAINER (tool_bar), home_button);
+ gtk_box_append (GTK_BOX (tool_bar), home_button);
sw = gtk_scrolled_window_new (NULL, NULL);
GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (sw, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), sw);
+ gtk_box_append (GTK_BOX (vbox), sw);
/* Create the store and fill it with the contents of '/' */
parent = g_strdup ("/");
toggle_sensitivity_callback (GtkWidget *togglebutton,
gpointer user_data)
{
- GtkContainer *container = user_data;
- GList *list;
- GList *tmp;
+ GtkWidget *child;
- list = gtk_container_get_children (container);
-
- tmp = list;
- while (tmp != NULL)
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (user_data));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
{
/* don't disable our toggle */
- if (GTK_WIDGET (tmp->data) != togglebutton)
- gtk_widget_set_sensitive (GTK_WIDGET (tmp->data),
- !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (togglebutton)));
-
- tmp = tmp->next;
+ if (child != togglebutton)
+ gtk_widget_set_sensitive (child, !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (togglebutton)));
}
-
- g_list_free (list);
}
gtk_window_set_child (GTK_WINDOW (window), base_vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 16);
- gtk_container_add (GTK_CONTAINER (base_vbox), hbox);
+ gtk_box_append (GTK_BOX (base_vbox), hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Image loaded from a file</u>");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
frame = gtk_frame_new (NULL);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
image = gtk_image_new_from_icon_name ("gtk3-demo");
gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Animation loaded from a file</u>");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
frame = gtk_frame_new (NULL);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
picture = gtk_picture_new_for_resource ("/images/floppybuddy.gif");
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Symbolic themed icon</u>");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
frame = gtk_frame_new (NULL);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic");
image = gtk_image_new_from_gicon (gicon);
/* Progressive */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Progressive image loading</u>");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
frame = gtk_frame_new (NULL);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
/* Create an empty image for now; the progressive loader
* will create the pixbuf and fill it in.
/* Video */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Displaying video</u>");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
frame = gtk_frame_new (NULL);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
video = gtk_video_new_for_resource ("/images/gtk-logo.webm");
gtk_media_stream_set_loop (gtk_video_get_media_stream (GTK_VIDEO (video)), TRUE);
/* Widget paintables */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>GtkWidgetPaintable</u>");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
paintable = gtk_widget_paintable_new (do_widget);
picture = gtk_picture_new_for_paintable (paintable);
gtk_widget_set_size_request (picture, 100, 100);
gtk_widget_set_valign (picture, GTK_ALIGN_START);
- gtk_container_add (GTK_CONTAINER (vbox), picture);
+ gtk_box_append (GTK_BOX (vbox), picture);
/* Sensitivity control */
button = gtk_toggle_button_new_with_mnemonic ("_Insensitive");
- gtk_container_add (GTK_CONTAINER (base_vbox), button);
+ gtk_box_append (GTK_BOX (base_vbox), button);
g_signal_connect (button, "toggled",
G_CALLBACK (toggle_sensitivity_callback),
gtk_window_set_child (GTK_WINDOW (window), vbox);
bar = gtk_info_bar_new ();
- gtk_container_add (GTK_CONTAINER (vbox), bar);
+ gtk_box_append (GTK_BOX (vbox), bar);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_INFO);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_INFO");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0);
- gtk_container_add (GTK_CONTAINER (bar), label);
+ gtk_box_append (GTK_BOX (bar), label);
button = gtk_toggle_button_new_with_label ("Message");
g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (actions), button);
+ gtk_box_append (GTK_BOX (actions), button);
bar = gtk_info_bar_new ();
- gtk_container_add (GTK_CONTAINER (vbox), bar);
+ gtk_box_append (GTK_BOX (vbox), bar);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_WARNING);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_WARNING");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0);
- gtk_container_add (GTK_CONTAINER (bar), label);
+ gtk_box_append (GTK_BOX (bar), label);
button = gtk_toggle_button_new_with_label ("Warning");
g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (actions), button);
+ gtk_box_append (GTK_BOX (actions), button);
bar = gtk_info_bar_new_with_buttons (_("_OK"), GTK_RESPONSE_OK, NULL);
gtk_info_bar_set_show_close_button (GTK_INFO_BAR (bar), TRUE);
g_signal_connect (bar, "response", G_CALLBACK (on_bar_response), window);
- gtk_container_add (GTK_CONTAINER (vbox), bar);
+ gtk_box_append (GTK_BOX (vbox), bar);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_QUESTION);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_QUESTION");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0);
- gtk_container_add (GTK_CONTAINER (bar), label);
+ gtk_box_append (GTK_BOX (bar), label);
gtk_info_bar_set_default_response (GTK_INFO_BAR (bar), GTK_RESPONSE_OK);
button = gtk_toggle_button_new_with_label ("Question");
g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (actions), button);
+ gtk_box_append (GTK_BOX (actions), button);
bar = gtk_info_bar_new ();
- gtk_container_add (GTK_CONTAINER (vbox), bar);
+ gtk_box_append (GTK_BOX (vbox), bar);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_ERROR);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_ERROR");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0);
- gtk_container_add (GTK_CONTAINER (bar), label);
+ gtk_box_append (GTK_BOX (bar), label);
button = gtk_toggle_button_new_with_label ("Error");
g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (actions), button);
+ gtk_box_append (GTK_BOX (actions), button);
bar = gtk_info_bar_new ();
- gtk_container_add (GTK_CONTAINER (vbox), bar);
+ gtk_box_append (GTK_BOX (vbox), bar);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_OTHER);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_OTHER");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0);
- gtk_container_add (GTK_CONTAINER (bar), label);
+ gtk_box_append (GTK_BOX (bar), label);
button = gtk_toggle_button_new_with_label ("Other");
g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (actions), button);
+ gtk_box_append (GTK_BOX (actions), button);
frame = gtk_frame_new ("An example of different info bars");
gtk_widget_set_margin_top (frame, 8);
gtk_widget_set_margin_bottom (frame, 8);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
gtk_widget_set_halign (actions, GTK_ALIGN_CENTER);
gtk_window_set_child (GTK_WINDOW (window), vbox);
label = gtk_label_new ("This is the bug list (note: not based on real data, it would be nice to have a nice ODBC interface to bugzilla or so, though).");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (sw), TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (vbox), sw);
+ gtk_box_append (GTK_BOX (vbox), sw);
/* create tree model */
model = create_model ();
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_window_set_child (GTK_WINDOW (window), vbox);
label = gtk_label_new ("Messages from GTK and friends");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (scrolled, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), scrolled);
+ gtk_box_append (GTK_BOX (vbox), scrolled);
listbox = gtk_list_box_new ();
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled), listbox);
gtk_widget_set_can_target (label, FALSE);
gtk_widget_set_margin_top (label, 8);
gtk_widget_set_margin_bottom (label, 8);
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), vbox);
gtk_entry_set_placeholder_text (GTK_ENTRY (entry), "Your Lucky Number");
gtk_widget_set_margin_top (entry, 8);
gtk_widget_set_margin_bottom (entry, 8);
- gtk_container_add (GTK_CONTAINER (vbox), entry);
+ gtk_box_append (GTK_BOX (vbox), entry);
gtk_window_set_child (GTK_WINDOW (window), overlay);
g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
gtk_widget_set_margin_end (vpaned, 5);
gtk_widget_set_margin_top (vpaned, 5);
gtk_widget_set_margin_bottom (vpaned, 5);
- gtk_container_add (GTK_CONTAINER (vbox), vpaned);
+ gtk_box_append (GTK_BOX (vbox), vpaned);
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_start_child (GTK_PANED (vpaned), hpaned);
/* Now create toggle buttons to control sizing */
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
create_pane_options (GTK_PANED (hpaned),
"Horizontal",
"Left",
"Right"));
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
create_pane_options (GTK_PANED (vpaned),
"Vertical",
"Top",
"activates-default", TRUE,
NULL);
g_signal_connect (entry, "notify::text", G_CALLBACK (update_button), NULL);
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), entry);
entry2 = gtk_password_entry_new ();
gtk_password_entry_set_show_peek_icon (GTK_PASSWORD_ENTRY (entry2), TRUE);
"activates-default", TRUE,
NULL);
g_signal_connect (entry2, "notify::text", G_CALLBACK (update_button), NULL);
- gtk_container_add (GTK_CONTAINER (box), entry2);
+ gtk_box_append (GTK_BOX (box), entry2);
button = gtk_button_new_with_mnemonic ("_Done");
gtk_widget_add_css_class (button, "suggested-action");
/* Add a drawing area */
drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (box), drawing_area);
+ gtk_box_append (GTK_BOX (box), drawing_area);
gtk_widget_add_css_class (drawing_area, GTK_STYLE_CLASS_VIEW);
gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (drawing_area),
/* And a label */
label = gtk_label_new (text);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
/* Set up fancy stuff on the label */
layout = gtk_label_get_layout (GTK_LABEL (label));
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "Search entry demo");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
/* Create our entry */
entry = gtk_entry_new ();
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
"edit-find-symbolic");
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (hbox), entry);
/* Create the find and cancel buttons */
notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
- gtk_container_add (GTK_CONTAINER (hbox), notebook);
+ gtk_box_append (GTK_BOX (hbox), notebook);
find_button = gtk_button_new_with_label ("Find");
g_signal_connect (find_button, "clicked",
entry = gtk_search_entry_new ();
container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_widget_set_halign (container, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (container), entry);
+ gtk_box_append (GTK_BOX (container), entry);
searchbar = gtk_search_bar_new ();
gtk_search_bar_connect_entry (GTK_SEARCH_BAR (searchbar), GTK_EDITABLE (entry));
gtk_search_bar_set_show_close_button (GTK_SEARCH_BAR (searchbar), FALSE);
gtk_search_bar_set_child (GTK_SEARCH_BAR (searchbar), container);
- gtk_container_add (GTK_CONTAINER (vbox), searchbar);
+ gtk_box_append (GTK_BOX (vbox), searchbar);
/* Hook the search bar to key presses */
gtk_search_bar_set_key_capture_widget (GTK_SEARCH_BAR (searchbar), window);
/* Help */
label = gtk_label_new ("Start Typing to search");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
/* Toggle button */
button = gtk_toggle_button_new_with_label ("Search");
g_object_bind_property (button, "active",
searchbar, "search-mode-enabled",
G_BINDING_BIDIRECTIONAL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
/* Result */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Result:");
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_widget_set_margin_start (label, 6);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
label = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
g_signal_connect (entry, "search-changed",
G_CALLBACK (search_changed_cb), label);
G_CALLBACK (changed_cb), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Signal:");
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_widget_set_margin_start (label, 6);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
label = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
g_signal_connect (entry, "search-changed",
G_CALLBACK (search_changed), label);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
sidebar = gtk_stack_sidebar_new ();
- gtk_container_add (GTK_CONTAINER (box), sidebar);
+ gtk_box_append (GTK_BOX (box), sidebar);
stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
gtk_widget_set_hexpand (stack, TRUE);
- gtk_container_add (GTK_CONTAINER (box), stack);
+ gtk_box_append (GTK_BOX (box), stack);
for (i=0; (c = *(pages+i)) != NULL; i++ )
{
/* Create one frame holding color options */
frame = gtk_frame_new ("Color Options");
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
table = gtk_grid_new ();
gtk_widget_set_margin_start (table, 5);
/* And another frame holding line style options */
frame = gtk_frame_new ("Line Options");
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
table = gtk_grid_new ();
gtk_widget_set_margin_start (table, 5);
/* And a check button to turn grouping on and off */
check_button = gtk_check_button_new_with_mnemonic ("_Enable grouping");
- gtk_container_add (GTK_CONTAINER (vbox), check_button);
+ gtk_box_append (GTK_BOX (vbox), check_button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
g_signal_connect (check_button, "toggled",
icon = gtk_image_new_from_paintable (paintable);
gtk_image_set_icon_size (GTK_IMAGE (icon), GTK_ICON_SIZE_LARGE);
- gtk_container_add (GTK_CONTAINER (container), icon);
+ gtk_box_append (GTK_BOX (container), icon);
}
GtkWidget *
gtk_widget_set_margin_end (vbox, 5);
gtk_widget_set_margin_top (vbox, 5);
gtk_widget_set_margin_bottom (vbox, 5);
- gtk_container_add (GTK_CONTAINER (content_area), vbox);
+ gtk_box_append (GTK_BOX (content_area), vbox);
/* Sensitive */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
spinner = gtk_spinner_new ();
- gtk_container_add (GTK_CONTAINER (hbox), spinner);
- gtk_container_add (GTK_CONTAINER (hbox), gtk_entry_new ());
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), spinner);
+ gtk_box_append (GTK_BOX (hbox), gtk_entry_new ());
+ gtk_box_append (GTK_BOX (vbox), hbox);
spinner_sensitive = spinner;
/* Disabled */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
spinner = gtk_spinner_new ();
- gtk_container_add (GTK_CONTAINER (hbox), spinner);
- gtk_container_add (GTK_CONTAINER (hbox), gtk_entry_new ());
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), spinner);
+ gtk_box_append (GTK_BOX (hbox), gtk_entry_new ());
+ gtk_box_append (GTK_BOX (vbox), hbox);
spinner_unsensitive = spinner;
gtk_widget_set_sensitive (hbox, FALSE);
button = gtk_button_new_with_label (_("Play"));
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (on_play_clicked), spinner);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label (_("Stop"));
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (on_stop_clicked), spinner);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
/* Start by default to test for:
* https://bugzilla.gnome.org/show_bug.cgi?id=598496 */
gtk_window_set_child (GTK_WINDOW (window), box);
entry = demo_tagged_entry_new ();
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), entry);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_set_halign (box2, GTK_ALIGN_END);
- gtk_container_add (GTK_CONTAINER (box), box2);
+ gtk_box_append (GTK_BOX (box), box2);
button = gtk_button_new_with_mnemonic ("Add _Tag");
g_signal_connect (button, "clicked", G_CALLBACK (add_tag), entry);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_check_button_new_with_mnemonic ("_Spinner");
g_signal_connect (button, "toggled", G_CALLBACK (toggle_spinner), entry);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_button_new_with_mnemonic ("_Done");
gtk_widget_add_css_class (button, "suggested-action");
guint timeout;
swindow = gtk_scrolled_window_new (NULL, NULL);
- gtk_container_add (GTK_CONTAINER (hbox), swindow);
+ gtk_box_append (GTK_BOX (hbox), swindow);
textview = gtk_text_view_new ();
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (swindow), textview);
gtk_widget_set_margin_bottom (vbox, 8);
gtk_window_set_child (GTK_WINDOW (window), vbox);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Jonathan's Holiday Card Planning Sheet"));
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (vbox), sw);
+ gtk_box_append (GTK_BOX (vbox), sw);
/* create model */
model = create_model ();
gtk_widget_set_size_request (box, 120, 90);
label = gtk_label_new (g_object_get_data (G_OBJECT (paintable), "description"));
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
picture = gtk_picture_new_for_paintable (paintable);
/* don't ever scale up, we want to be as accurate as possible */
gtk_widget_set_halign (picture, GTK_ALIGN_CENTER);
gtk_widget_set_valign (picture, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (box), picture);
+ gtk_box_append (GTK_BOX (box), picture);
row = gtk_list_box_row_new ();
gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);
{
if (silver)
{
- gtk_container_remove (GTK_CONTAINER (widget), silver);
+ gtk_list_box_remove (GTK_LIST_BOX (widget), silver);
g_object_set_data (G_OBJECT (widget), "Silver", NULL);
}
if (gold)
{
- gtk_container_remove (GTK_CONTAINER (widget), gold);
+ gtk_list_box_remove (GTK_LIST_BOX (widget), gold);
g_object_set_data (G_OBJECT (widget), "Gold", NULL);
}
"margin-bottom", 6,
"xalign", 0.0,
NULL);
- gtk_container_add (GTK_CONTAINER (row), label);
+ gtk_box_append (GTK_BOX (row), label);
gdk_rgba_parse (&rgba, color);
swatch = g_object_new (g_type_from_name ("GtkColorSwatch"),
"rgba", &rgba,
"height-request", 24,
NULL);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), swatch);
- gtk_container_add (GTK_CONTAINER (row), box);
+ gtk_box_append (GTK_BOX (box), swatch);
+ gtk_box_append (GTK_BOX (row), box);
gtk_list_box_insert (GTK_LIST_BOX (widget), row, -1);
row = gtk_widget_get_parent (row);
gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE);
"hexpand", TRUE,
"xalign", 0.0,
NULL);
- gtk_container_add (GTK_CONTAINER (row), label);
+ gtk_box_append (GTK_BOX (row), label);
gdk_rgba_parse (&rgba, colors[i].color);
swatch = g_object_new (g_type_from_name ("GtkColorSwatch"),
"rgba", &rgba,
"height-request", 24,
NULL);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), swatch);
- gtk_container_add (GTK_CONTAINER (row), box);
+ gtk_box_append (GTK_BOX (box), swatch);
+ gtk_box_append (GTK_BOX (row), box);
gtk_list_box_insert (GTK_LIST_BOX (widget), row, -1);
row = gtk_widget_get_parent (row);
gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE);
if (response == GTK_RESPONSE_CANCEL)
return;
- box = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
- children = gtk_container_get_children (GTK_CONTAINER (box));
- box = children->data;
- g_list_free (children);
+ box = gtk_widget_get_first_child (gtk_dialog_get_content_area (GTK_DIALOG (dialog)));
g_assert (GTK_IS_FLOW_BOX (box));
children = gtk_flow_box_get_selected_children (GTK_FLOW_BOX (box));
info->window = gtk_window_new ();
info->include_decorations = FALSE;
gtk_widget_show (widget);
- gtk_container_add (GTK_CONTAINER (info->window), widget);
+ gtk_box_append (GTK_BOX (info->window), widget);
}
info->no_focus = TRUE;
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
sw = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (sw), TRUE);
- gtk_container_add (GTK_CONTAINER (widget), sw);
+ gtk_box_append (GTK_BOX (widget), sw);
sw = gtk_switch_new ();
- gtk_container_add (GTK_CONTAINER (widget), sw);
+ gtk_box_append (GTK_BOX (widget), sw);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
widget = gtk_menu_button_new ();
image = gtk_image_new ();
gtk_image_set_from_icon_name (GTK_IMAGE (image), "emblem-system-symbolic");
- gtk_container_add (GTK_CONTAINER (widget), image);
+ gtk_box_append (GTK_BOX (widget), image);
menu = gtk_popover_new ();
gtk_menu_button_set_popover (GTK_MENU_BUTTON (widget), menu);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("Menu Button"));
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new ("Menu Button"));
return new_widget_info ("menu-button", vbox, SMALL);
}
widget = gtk_lock_button_new (g_object_new (G_TYPE_TEST_PERMISSION, NULL));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Lock Button"));
gtk_widget_set_halign (vbox, GTK_ALIGN_CENTER);
gtk_widget_set_valign (vbox, GTK_ALIGN_CENTER);
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
radio = gtk_radio_button_new_with_mnemonic (NULL, "Radio Button _One");
- gtk_container_add (GTK_CONTAINER (widget), radio);
+ gtk_box_append (GTK_BOX (widget), radio);
radio = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (radio), "Radio Button _Two");
- gtk_container_add (GTK_CONTAINER (widget), radio);
+ gtk_box_append (GTK_BOX (widget), radio);
radio = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (radio), "Radio Button T_hree");
- gtk_container_add (GTK_CONTAINER (widget), radio);
+ gtk_box_append (GTK_BOX (widget), radio);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
gtk_widget_hide (button);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (box), widget);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), widget);
+ gtk_box_append (GTK_BOX (box), button);
gtk_accel_label_set_accel (GTK_ACCEL_LABEL (widget), GDK_KEY_Q, GDK_CONTROL_MASK);
widget = gtk_info_bar_new ();
gtk_info_bar_set_show_close_button (GTK_INFO_BAR (widget), TRUE);
gtk_info_bar_set_message_type (GTK_INFO_BAR (widget), GTK_MESSAGE_INFO);
- gtk_container_add (GTK_CONTAINER (widget),
+ gtk_box_append (GTK_BOX (widget),
gtk_label_new ("Info Bar"));
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
entry = gtk_search_entry_new ();
gtk_editable_set_text (GTK_EDITABLE (entry), "Search Bar");
- gtk_container_add (GTK_CONTAINER (widget), entry);
+ gtk_box_append (GTK_BOX (widget), entry);
gtk_widget_show (entry);
gtk_search_bar_set_show_close_button (GTK_SEARCH_BAR (widget), TRUE);
gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (widget), TRUE);
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
view = gtk_text_view_new ();
- gtk_container_add (GTK_CONTAINER (box), view);
+ gtk_box_append (GTK_BOX (box), view);
info = new_widget_info ("search-bar", box, SMALL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
view = gtk_text_view_new ();
- gtk_container_add (GTK_CONTAINER (box), view);
+ gtk_box_append (GTK_BOX (box), view);
widget = gtk_action_bar_new ();
button = gtk_button_new_from_icon_name ("object-select-symbolic");
gtk_widget_show (button);
- gtk_container_add (GTK_CONTAINER (widget), button);
+ gtk_box_append (GTK_BOX (widget), button);
button = gtk_button_new_from_icon_name ("call-start-symbolic");
gtk_widget_show (button);
- gtk_container_add (GTK_CONTAINER (widget), button);
+ gtk_box_append (GTK_BOX (widget), button);
g_object_set (gtk_widget_get_parent (button),
"margin-start", 6,
"margin-end", 6,
gtk_widget_show (widget);
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
info = new_widget_info ("action-bar", box, SMALL);
widget = gtk_frame_new (NULL);
text_view = gtk_text_view_new ();
- gtk_container_add (GTK_CONTAINER (widget), text_view);
+ gtk_box_append (GTK_BOX (widget), text_view);
/* Bad hack to add some size to the widget */
gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)),
"Multiline\nText\n\n", -1);
g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "xalign", 0.5, NULL),
"text", 2, NULL);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
- gtk_container_add (GTK_CONTAINER (widget), tree_view);
+ gtk_box_append (GTK_BOX (widget), tree_view);
info = new_widget_info ("list-and-tree", widget, MEDIUM);
info->no_focus = FALSE;
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_view), 0);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_view), 1);
- gtk_container_add (GTK_CONTAINER (widget), icon_view);
+ gtk_box_append (GTK_BOX (widget), icon_view);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Icon View"));
info = new_widget_info ("icon-view", vbox, MEDIUM);
picker = gtk_color_button_new_with_rgba (&color);
gtk_widget_set_halign (picker, GTK_ALIGN_CENTER);
gtk_widget_set_valign (picker, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), picker);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), picker);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Color Button"));
return new_widget_info ("color-button", vbox, SMALL);
picker = gtk_font_button_new_with_font ("Sans Serif 10");
gtk_widget_set_halign (picker, GTK_ALIGN_CENTER);
gtk_widget_set_valign (picker, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), picker);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), picker);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Font Button"));
return new_widget_info ("font-button", vbox, SMALL);
gtk_widget_set_size_request (picker, 150, -1);
gtk_widget_set_halign (picker, GTK_ALIGN_CENTER);
gtk_widget_set_valign (picker, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox2), picker);
- gtk_container_add (GTK_CONTAINER (vbox2),
+ gtk_box_append (GTK_BOX (vbox2), picker);
+ gtk_box_append (GTK_BOX (vbox2),
gtk_label_new ("File Button (Files)"));
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
vbox2);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
g_object_unref (file);
gtk_widget_set_halign (picker, GTK_ALIGN_CENTER);
gtk_widget_set_valign (picker, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox2), picker);
- gtk_container_add (GTK_CONTAINER (vbox2),
+ gtk_box_append (GTK_BOX (vbox2), picker);
+ gtk_box_append (GTK_BOX (vbox2),
gtk_label_new ("File Button (Select Folder)"));
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
vbox2);
return new_widget_info ("file-button", vbox, MEDIUM);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
- gtk_container_add (GTK_CONTAINER (hbox),
+ gtk_box_append (GTK_BOX (hbox),
gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
- gtk_container_add (GTK_CONTAINER (hbox),
+ gtk_box_append (GTK_BOX (hbox),
gtk_separator_new (GTK_ORIENTATION_VERTICAL));
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox),
g_object_new (GTK_TYPE_LABEL,
"label", "Horizontal and Vertical\nSeparators",
"justify", GTK_JUSTIFY_CENTER,
gtk_paned_set_resize_end_child (GTK_PANED (pane), FALSE);
gtk_paned_set_shrink_end_child (GTK_PANED (pane), FALSE);
- gtk_container_add (GTK_CONTAINER (hbox), pane);
+ gtk_box_append (GTK_BOX (hbox), pane);
pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
frame = gtk_frame_new ("");
gtk_paned_set_resize_end_child (GTK_PANED (pane), FALSE);
gtk_paned_set_shrink_end_child (GTK_PANED (pane), FALSE);
- gtk_container_add (GTK_CONTAINER (hbox), pane);
+ gtk_box_append (GTK_BOX (hbox), pane);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox),
g_object_new (GTK_TYPE_LABEL,
"label", "Horizontal and Vertical\nPanes",
"justify", GTK_JUSTIFY_CENTER,
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Progress Bar"));
return new_widget_info ("progressbar", vbox, SMALL);
gtk_level_bar_set_value (GTK_LEVEL_BAR (widget), 0.333);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Level Bar"));
return new_widget_info ("levelbar", vbox, SMALL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Scrollbar"));
return new_widget_info ("scrollbar", vbox, SMALL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Spin Button"));
return new_widget_info ("spinbutton", vbox, SMALL);
GtkWidget *vbox;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Status Bar"));
widget = gtk_statusbar_new ();
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_statusbar_push (GTK_STATUSBAR (widget), 0, "Hold on...");
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
info = new_widget_info ("statusbar", vbox, SMALL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
- gtk_container_add (GTK_CONTAINER (hbox),
+ gtk_box_append (GTK_BOX (hbox),
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
0.0, 100.0, 1.0));
- gtk_container_add (GTK_CONTAINER (hbox),
+ gtk_box_append (GTK_BOX (hbox),
gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
0.0, 100.0, 1.0));
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox),
g_object_new (GTK_TYPE_LABEL,
"label", "Horizontal and Vertical\nScales",
"justify", GTK_JUSTIFY_CENTER,
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Image"));
return new_widget_info ("image", vbox, SMALL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Spinner"));
return new_widget_info ("spinner", vbox, SMALL);
gtk_widget_set_size_request (widget, 100, 250);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (widget), box);
+ gtk_box_append (GTK_BOX (widget), box);
button = gtk_volume_button_new ();
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
gtk_scale_button_set_value (GTK_SCALE_BUTTON (button), 33);
popup = gtk_scale_button_get_popup (GTK_SCALE_BUTTON (button));
picker = gtk_app_chooser_button_new ("text/plain");
gtk_widget_set_halign (picker, GTK_ALIGN_CENTER);
gtk_widget_set_valign (picker, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), picker);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), picker);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Application Button"));
return new_widget_info ("appchooserbutton", vbox, SMALL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), switcher);
- gtk_container_add (GTK_CONTAINER (vbox), stack);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), switcher);
+ gtk_box_append (GTK_BOX (vbox), stack);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Stack"));
return new_widget_info ("stack", vbox, ASIS);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), switcher);
- gtk_container_add (GTK_CONTAINER (vbox), stack);
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox), switcher);
+ gtk_box_append (GTK_BOX (vbox), stack);
+ gtk_box_append (GTK_BOX (vbox),
gtk_label_new ("Stack Switcher"));
return new_widget_info ("stackswitcher", vbox, ASIS);
frame = gtk_frame_new (NULL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (hbox), sidebar);
- gtk_container_add (GTK_CONTAINER (hbox), gtk_separator_new (GTK_ORIENTATION_VERTICAL));
- gtk_container_add (GTK_CONTAINER (hbox), stack);
+ gtk_box_append (GTK_BOX (hbox), sidebar);
+ gtk_box_append (GTK_BOX (hbox), gtk_separator_new (GTK_ORIENTATION_VERTICAL));
+ gtk_box_append (GTK_BOX (hbox), stack);
gtk_frame_set_child (GTK_FRAME (frame), hbox);
return new_widget_info ("sidebar", frame, ASIS);
button = gtk_label_new ("List Box");
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (row), button);
+ gtk_box_append (GTK_BOX (row), button);
gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (row), gtk_label_new ("Line One"));
+ gtk_box_append (GTK_BOX (row), gtk_label_new ("Line One"));
button = gtk_check_button_new ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_halign (button, GTK_ALIGN_END);
- gtk_container_add (GTK_CONTAINER (row), button);
+ gtk_box_append (GTK_BOX (row), button);
gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
gtk_list_box_select_row (GTK_LIST_BOX (list), GTK_LIST_BOX_ROW (gtk_widget_get_parent (row)));
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (row), gtk_label_new ("Line Two"));
+ gtk_box_append (GTK_BOX (row), gtk_label_new ("Line Two"));
button = gtk_button_new_with_label ("2");
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_halign (button, GTK_ALIGN_END);
- gtk_container_add (GTK_CONTAINER (row), button);
+ gtk_box_append (GTK_BOX (row), button);
gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (row), gtk_label_new ("Line Three"));
+ gtk_box_append (GTK_BOX (row), gtk_label_new ("Line Three"));
button = gtk_entry_new ();
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_halign (button, GTK_ALIGN_END);
- gtk_container_add (GTK_CONTAINER (row), button);
+ gtk_box_append (GTK_BOX (row), button);
gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
- gtk_container_add (GTK_CONTAINER (widget), list);
+ gtk_box_append (GTK_BOX (widget), list);
info = new_widget_info ("list-box", widget, MEDIUM);
info->no_focus = FALSE;
gtk_flow_box_set_max_children_per_line (GTK_FLOW_BOX (box), 2);
gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (box), GTK_SELECTION_BROWSE);
button = gtk_label_new ("Child One");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_label ("Child Two");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
child = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
- gtk_container_add (GTK_CONTAINER (child), gtk_label_new ("Child Three"));
+ gtk_box_append (GTK_BOX (child), gtk_label_new ("Child Three"));
button = gtk_check_button_new ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
- gtk_container_add (GTK_CONTAINER (child), button);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (child), button);
+ gtk_box_append (GTK_BOX (box), child);
gtk_flow_box_select_child (GTK_FLOW_BOX (box),
GTK_FLOW_BOX_CHILD (gtk_widget_get_parent (child)));
- gtk_container_add (GTK_CONTAINER (widget), box);
+ gtk_box_append (GTK_BOX (widget), box);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("Flow Box"));
+ gtk_box_append (GTK_BOX (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new ("Flow Box"));
info = new_widget_info ("flow-box", vbox, ASIS);
info->no_focus = FALSE;
widget = gtk_frame_new (NULL);
gears = gtk_gears_new ();
- gtk_container_add (GTK_CONTAINER (widget), gears);
+ gtk_box_append (GTK_BOX (widget), gears);
info = new_widget_info ("glarea", widget, MEDIUM);
--- /dev/null
+#include <gtk/gtk.h>
+
+#include "exampleapp.h"
+#include "exampleappwin.h"
+
+struct _ExampleAppWindow
+{
+ GtkApplicationWindow parent;
+
+ GSettings *settings;
+ GtkWidget *stack;
+ GtkWidget *search;
+ GtkWidget *searchbar;
+ GtkWidget *searchentry;
+ GtkWidget *gears;
+ GtkWidget *sidebar;
+ GtkWidget *words;
+ GtkWidget *lines;
+ GtkWidget *lines_label;
+};
+
+G_DEFINE_TYPE (ExampleAppWindow, example_app_window, GTK_TYPE_APPLICATION_WINDOW)
+
+static void
+search_text_changed (GtkEntry *entry,
+ ExampleAppWindow *win)
+{
+ const gchar *text;
+ GtkWidget *tab;
+ GtkWidget *view;
+ GtkTextBuffer *buffer;
+ GtkTextIter start, match_start, match_end;
+
+ text = gtk_editable_get_text (GTK_EDITABLE (entry));
+
+ if (text[0] == '\0')
+ return;
+
+ tab = gtk_stack_get_visible_child (GTK_STACK (win->stack));
+ view = gtk_scrolled_window_get_child (GTK_SCROLLED_WINDOW (tab));
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
+
+ /* Very simple-minded search implementation */
+ gtk_text_buffer_get_start_iter (buffer, &start);
+ if (gtk_text_iter_forward_search (&start, text, GTK_TEXT_SEARCH_CASE_INSENSITIVE,
+ &match_start, &match_end, NULL))
+ {
+ gtk_text_buffer_select_range (buffer, &match_start, &match_end);
+ gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (view), &match_start,
+ 0.0, FALSE, 0.0, 0.0);
+ }
+}
+
+static void
+find_word (GtkButton *button,
+ ExampleAppWindow *win)
+{
+ const gchar *word;
+
+ word = gtk_button_get_label (button);
+ gtk_editable_set_text (GTK_EDITABLE (win->searchentry), word);
+}
+
+static void
+update_words (ExampleAppWindow *win)
+{
+ GHashTable *strings;
+ GHashTableIter iter;
+ GtkWidget *tab, *view, *row;
+ GtkTextBuffer *buffer;
+ GtkTextIter start, end;
+ gchar *word, *key;
+ GtkWidget *child;
+
+ tab = gtk_stack_get_visible_child (GTK_STACK (win->stack));
+
+ if (tab == NULL)
+ return;
+
+ view = gtk_scrolled_window_get_child (GTK_SCROLLED_WINDOW (tab));
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
+
+ strings = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+
+ gtk_text_buffer_get_start_iter (buffer, &start);
+ while (!gtk_text_iter_is_end (&start))
+ {
+ while (!gtk_text_iter_starts_word (&start))
+ {
+ if (!gtk_text_iter_forward_char (&start))
+ goto done;
+ }
+ end = start;
+ if (!gtk_text_iter_forward_word_end (&end))
+ goto done;
+ word = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
+ g_hash_table_add (strings, g_utf8_strdown (word, -1));
+ g_free (word);
+ start = end;
+ }
+
+done:
+ while ((child = gtk_widget_get_first_child (win->words)))
+ gtk_list_box_remove (GTK_LIST_BOX (win->words), child);
+
+ g_hash_table_iter_init (&iter, strings);
+ while (g_hash_table_iter_next (&iter, (gpointer *)&key, NULL))
+ {
+ row = gtk_button_new_with_label (key);
+ g_signal_connect (row, "clicked",
+ G_CALLBACK (find_word), win);
+ gtk_box_append (GTK_BOX (win->words), row);
+ }
+
+ g_hash_table_unref (strings);
+}
+
+static void
+update_lines (ExampleAppWindow *win)
+{
+ GtkWidget *tab, *view;
+ GtkTextBuffer *buffer;
+ int count;
+ gchar *lines;
+
+ tab = gtk_stack_get_visible_child (GTK_STACK (win->stack));
+
+ if (tab == NULL)
+ return;
+
+ view = gtk_scrolled_window_get_child (GTK_SCROLLED_WINDOW (tab));
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
+
+ count = gtk_text_buffer_get_line_count (buffer);
+ lines = g_strdup_printf ("%d", count);
+ gtk_label_set_text (GTK_LABEL (win->lines), lines);
+ g_free (lines);
+}
+
+static void
+visible_child_changed (GObject *stack,
+ GParamSpec *pspec,
+ ExampleAppWindow *win)
+{
+ if (gtk_widget_in_destruction (GTK_WIDGET (stack)))
+ return;
+
+ gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (win->searchbar), FALSE);
+ update_words (win);
+ update_lines (win);
+}
+
+static void
+words_changed (GObject *sidebar,
+ GParamSpec *pspec,
+ ExampleAppWindow *win)
+{
+ update_words (win);
+}
+
+static void
+example_app_window_init (ExampleAppWindow *win)
+{
+ GtkBuilder *builder;
+ GMenuModel *menu;
+ GAction *action;
+
+ gtk_widget_init_template (GTK_WIDGET (win));
+ win->settings = g_settings_new ("org.gtk.exampleapp");
+
+ g_settings_bind (win->settings, "transition",
+ win->stack, "transition-type",
+ G_SETTINGS_BIND_DEFAULT);
+
+ g_settings_bind (win->settings, "show-words",
+ win->sidebar, "reveal-child",
+ G_SETTINGS_BIND_DEFAULT);
+
+ g_object_bind_property (win->search, "active",
+ win->searchbar, "search-mode-enabled",
+ G_BINDING_BIDIRECTIONAL);
+
+ g_signal_connect (win->sidebar, "notify::reveal-child",
+ G_CALLBACK (words_changed), win);
+
+ builder = gtk_builder_new_from_resource ("/org/gtk/exampleapp/gears-menu.ui");
+ menu = G_MENU_MODEL (gtk_builder_get_object (builder, "menu"));
+ gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (win->gears), menu);
+ g_object_unref (builder);
+
+ action = g_settings_create_action (win->settings, "show-words");
+ g_action_map_add_action (G_ACTION_MAP (win), action);
+ g_object_unref (action);
+
+ action = (GAction*) g_property_action_new ("show-lines", win->lines, "visible");
+ g_action_map_add_action (G_ACTION_MAP (win), action);
+ g_object_unref (action);
+
+ g_object_bind_property (win->lines, "visible",
+ win->lines_label, "visible",
+ G_BINDING_DEFAULT);
+
+ g_object_set (gtk_settings_get_default (), "gtk-shell-shows-app-menu", FALSE, NULL);
+ gtk_application_window_set_show_menubar (GTK_APPLICATION_WINDOW (win), TRUE);
+}
+
+static void
+example_app_window_dispose (GObject *object)
+{
+ ExampleAppWindow *win;
+
+ win = EXAMPLE_APP_WINDOW (object);
+
+ g_clear_object (&win->settings);
+
+ G_OBJECT_CLASS (example_app_window_parent_class)->dispose (object);
+}
+
+static void
+example_app_window_class_init (ExampleAppWindowClass *class)
+{
+ G_OBJECT_CLASS (class)->dispose = example_app_window_dispose;
+
+ gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (class),
+ "/org/gtk/exampleapp/window.ui");
+
+ gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), ExampleAppWindow, stack);
+ gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), ExampleAppWindow, search);
+ gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), ExampleAppWindow, searchbar);
+ gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), ExampleAppWindow, searchentry);
+ gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), ExampleAppWindow, gears);
+ gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), ExampleAppWindow, words);
+ gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), ExampleAppWindow, sidebar);
+ gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), ExampleAppWindow, lines);
+ gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), ExampleAppWindow, lines_label);
+
+ gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), search_text_changed);
+ gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), visible_child_changed);
+}
+
+ExampleAppWindow *
+example_app_window_new (ExampleApp *app)
+{
+ return g_object_new (EXAMPLE_APP_WINDOW_TYPE, "application", app, NULL);
+}
+
+void
+example_app_window_open (ExampleAppWindow *win,
+ GFile *file)
+{
+ gchar *basename;
+ GtkWidget *scrolled, *view;
+ gchar *contents;
+ gsize length;
+ GtkTextBuffer *buffer;
+ GtkTextTag *tag;
+ GtkTextIter start_iter, end_iter;
+
+ basename = g_file_get_basename (file);
+
+ scrolled = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_hexpand (scrolled, TRUE);
+ gtk_widget_set_vexpand (scrolled, TRUE);
+ view = gtk_text_view_new ();
+ gtk_text_view_set_editable (GTK_TEXT_VIEW (view), FALSE);
+ gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE);
+ gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled), view);
+ gtk_stack_add_titled (GTK_STACK (win->stack), scrolled, basename, basename);
+
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
+
+ if (g_file_load_contents (file, NULL, &contents, &length, NULL, NULL))
+ {
+ gtk_text_buffer_set_text (buffer, contents, length);
+ g_free (contents);
+ }
+
+ tag = gtk_text_buffer_create_tag (buffer, NULL, NULL);
+ g_settings_bind (win->settings, "font",
+ tag, "font",
+ G_SETTINGS_BIND_DEFAULT);
+
+ gtk_text_buffer_get_start_iter (buffer, &start_iter);
+ gtk_text_buffer_get_end_iter (buffer, &end_iter);
+ gtk_text_buffer_apply_tag (buffer, tag, &start_iter, &end_iter);
+
+ g_free (basename);
+
+ gtk_widget_set_sensitive (win->search, TRUE);
+
+ update_words (win);
+ update_lines (win);
+}
GtkWidget *tab, *view, *row;
GtkTextBuffer *buffer;
GtkTextIter start, end;
- GList *children, *l;
gchar *word, *key;
+ GtkWidget *child;
tab = gtk_stack_get_visible_child (GTK_STACK (win->stack));
}
done:
- children = gtk_container_get_children (GTK_CONTAINER (win->words));
- for (l = children; l; l = l->next)
- gtk_container_remove (GTK_CONTAINER (win->words), GTK_WIDGET (l->data));
- g_list_free (children);
+ while ((child = gtk_widget_get_first_child (win->words)))
+ gtk_list_box_remove (GTK_LIST_BOX (win->words), child);
g_hash_table_iter_init (&iter, strings);
while (g_hash_table_iter_next (&iter, (gpointer *)&key, NULL))
row = gtk_button_new_with_label (key);
g_signal_connect (row, "clicked",
G_CALLBACK (find_word), win);
- gtk_container_add (GTK_CONTAINER (win->words), row);
+ gtk_box_append (GTK_BOX (win->words), row);
}
g_hash_table_unref (strings);
GtkWidget *tab, *view, *row;
GtkTextBuffer *buffer;
GtkTextIter start, end;
- GList *children, *l;
gchar *word, *key;
+ GtkWidget *child;
tab = gtk_stack_get_visible_child (GTK_STACK (win->stack));
}
done:
- children = gtk_container_get_children (GTK_CONTAINER (win->words));
- for (l = children; l; l = l->next)
- gtk_container_remove (GTK_CONTAINER (win->words), GTK_WIDGET (l->data));
- g_list_free (children);
+ while ((child = gtk_widget_get_first_child (win->words)))
+ gtk_list_box_remove (GTK_LIST_BOX (win->words), child);
g_hash_table_iter_init (&iter, strings);
while (g_hash_table_iter_next (&iter, (gpointer *)&key, NULL))
row = gtk_button_new_with_label (key);
g_signal_connect (row, "clicked",
G_CALLBACK (find_word), win);
- gtk_container_add (GTK_CONTAINER (win->words), row);
+ gtk_box_append (GTK_BOX (win->words), row);
}
g_hash_table_unref (strings);
button = gtk_toggle_button_new ();
gtk_button_set_icon_name (GTK_BUTTON (button), "format-justify-left");
gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (button), "win.justify::left");
- gtk_container_add (GTK_CONTAINER (toolbar), button);
+ gtk_box_append (GTK_BOX (toolbar), button);
button = gtk_toggle_button_new ();
gtk_button_set_icon_name (GTK_BUTTON (button), "format-justify-center");
gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (button), "win.justify::center");
- gtk_container_add (GTK_CONTAINER (toolbar), button);
+ gtk_box_append (GTK_BOX (toolbar), button);
button = gtk_toggle_button_new ();
gtk_button_set_icon_name (GTK_BUTTON (button), "format-justify-right");
gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (button), "win.justify::right");
- gtk_container_add (GTK_CONTAINER (toolbar), button);
+ gtk_box_append (GTK_BOX (toolbar), button);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_set_halign (box, GTK_ALIGN_END);
label = gtk_label_new ("Fullscreen:");
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
sw = gtk_switch_new ();
gtk_widget_set_valign (sw, GTK_ALIGN_CENTER);
gtk_actionable_set_action_name (GTK_ACTIONABLE (sw), "win.fullscreen");
- gtk_container_add (GTK_CONTAINER (box), sw);
- gtk_container_add (GTK_CONTAINER (toolbar), box);
+ gtk_box_append (GTK_BOX (box), sw);
+ gtk_box_append (GTK_BOX (toolbar), box);
gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 1, 1);
gtk_window_set_application (GTK_WINDOW (dialog), app);
actions = gtk_application_list_action_descriptions (app);
combo = gtk_combo_box_text_new ();
- gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), combo);
+ gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), combo);
for (i = 0; actions[i]; i++)
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), actions[i], actions[i]);
g_signal_connect (combo, "changed", G_CALLBACK (combo_changed), dialog);
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), entry);
+ gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), entry);
gtk_dialog_add_button (GTK_DIALOG (dialog), "Close", GTK_RESPONSE_CLOSE);
gtk_dialog_add_button (GTK_DIALOG (dialog), "Set", GTK_RESPONSE_APPLY);
g_signal_connect (dialog, "response", G_CALLBACK (response), dialog);
button = gtk_button_new_with_label ("Hello World");
g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
gtk_widget_show (window);
}
entry = gtk_search_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), entry);
menu_button = gtk_menu_button_new ();
- gtk_container_add (GTK_CONTAINER (box), menu_button);
+ gtk_box_append (GTK_BOX (box), menu_button);
gtk_search_bar_connect_entry (GTK_SEARCH_BAR (search_bar), GTK_EDITABLE (entry));
gtk_search_bar_set_key_capture_widget (GTK_SEARCH_BAR (search_bar), window);
AtkObject *accessible_array[1];
AtkRelation* relation;
- if (!gtk_widget_get_can_focus (mnemonic_widget))
- {
- /*
- * Handle the case where a GtkFileChooserButton is specified
- * as the mnemonic widget. use the combobox which is a child of the
- * GtkFileChooserButton as the mnemonic widget. See bug #359843.
- */
- if (GTK_IS_BOX (mnemonic_widget))
- {
- GList *list, *tmpl;
-
- list = gtk_container_get_children (GTK_CONTAINER (mnemonic_widget));
- if (g_list_length (list) == 2)
- {
- tmpl = g_list_last (list);
- if (GTK_IS_COMBO_BOX(tmpl->data))
- {
- mnemonic_widget = GTK_WIDGET(tmpl->data);
- }
- }
- g_list_free (list);
- }
- }
accessible_array[0] = gtk_widget_get_accessible (mnemonic_widget);
relation = atk_relation_new (accessible_array, 1,
ATK_RELATION_LABEL_FOR);
static GtkWidget *
-find_label_child (GtkContainer *container)
+find_label_child (GtkWidget *widget)
{
- GList *children, *tmp_list;
GtkWidget *child;
- children = gtk_container_get_children (container);
-
- child = NULL;
- for (tmp_list = children; tmp_list != NULL; tmp_list = tmp_list->next)
+ for (child = gtk_widget_get_first_child (widget);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
{
- if (GTK_IS_LABEL (tmp_list->data))
- {
- child = GTK_WIDGET (tmp_list->data);
- break;
- }
- else if (GTK_IS_CONTAINER (tmp_list->data))
+ if (GTK_IS_LABEL (child))
+ return child;
+ else
{
- child = find_label_child (GTK_CONTAINER (tmp_list->data));
- if (child)
- break;
+ GtkWidget *w = find_label_child (child);
+ if (w)
+ return w;
}
}
- g_list_free (children);
- return child;
+ return NULL;
}
static GtkWidget *
if (GTK_IS_LABEL (child))
return child;
- if (GTK_IS_CONTAINER (child))
- child = find_label_child (GTK_CONTAINER (child));
-
- return child;
+ return find_label_child (child);
}
static const gchar *
obj->role = ATK_ROLE_SCROLL_PANE;
}
-static gint
+static int
gtk_scrolled_window_accessible_get_n_children (AtkObject *object)
{
GtkWidget *widget;
GtkScrolledWindow *scrolled_window;
- GList *children;
gint n_children;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (object));
scrolled_window = GTK_SCROLLED_WINDOW (widget);
- children = gtk_container_get_children (GTK_CONTAINER (widget));
- n_children = g_list_length (children);
- g_list_free (children);
-
+ n_children = 0;
+ if (gtk_scrolled_window_get_child (scrolled_window))
+ n_children++;
if (gtk_scrolled_window_get_hscrollbar (scrolled_window))
n_children++;
if (gtk_scrolled_window_get_vscrollbar (scrolled_window))
GtkWidget *widget;
GtkScrolledWindow *scrolled_window;
GtkWidget *hscrollbar, *vscrollbar;
- GList *children, *tmp_list;
- gint n_children;
- AtkObject *accessible = NULL;
+ GtkWidget *c;
+ GtkWidget *chosen = NULL;
g_return_val_if_fail (child >= 0, NULL);
return NULL;
scrolled_window = GTK_SCROLLED_WINDOW (widget);
+ c = gtk_scrolled_window_get_child (scrolled_window);
hscrollbar = gtk_scrolled_window_get_hscrollbar (scrolled_window);
vscrollbar = gtk_scrolled_window_get_vscrollbar (scrolled_window);
- children = gtk_container_get_children (GTK_CONTAINER (widget));
- n_children = g_list_length (children);
-
- if (child == n_children)
- {
- if (gtk_scrolled_window_get_hscrollbar (scrolled_window))
- accessible = gtk_widget_get_accessible (hscrollbar);
- else if (gtk_scrolled_window_get_vscrollbar (scrolled_window))
- accessible = gtk_widget_get_accessible (vscrollbar);
- }
- else if (child == n_children + 1 &&
- gtk_scrolled_window_get_hscrollbar (scrolled_window) &&
- gtk_scrolled_window_get_vscrollbar (scrolled_window))
- accessible = gtk_widget_get_accessible (vscrollbar);
- else if (child < n_children)
- {
- tmp_list = g_list_nth (children, child);
- if (tmp_list)
- accessible = gtk_widget_get_accessible (GTK_WIDGET (tmp_list->data));
- }
+ if (child == 2)
+ chosen = vscrollbar;
+ else if (child == 1)
+ chosen = c ? hscrollbar : vscrollbar;
+ else if (child == 0)
+ chosen = c ? c : (hscrollbar ? hscrollbar : vscrollbar);
- g_list_free (children);
- if (accessible)
- g_object_ref (accessible);
+ if (chosen)
+ return g_object_ref (gtk_widget_get_accessible (chosen));
- return accessible;
+ return NULL;
}
static void
GtkWidget *widget;
GtkWidget *parent_widget;
gint index;
- GList *children;
+ GtkWidget *ch;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
}
parent_widget = gtk_widget_get_parent (widget);
- if (GTK_IS_CONTAINER (parent_widget))
+ for (ch = gtk_widget_get_first_child (parent_widget), index = 0;
+ ch != NULL;
+ ch = gtk_widget_get_next_sibling (ch), index++)
{
- children = gtk_container_get_children (GTK_CONTAINER (parent_widget));
- index = g_list_index (children, widget);
- g_list_free (children);
+ if (ch == widget)
+ break;
}
- else if (GTK_IS_WIDGET (parent_widget))
- {
- GtkWidget *child;
-
- for (child = gtk_widget_get_first_child (parent_widget), index = 0; child; child = gtk_widget_get_next_sibling (child), index++)
- {
- if (child == widget)
- break;
- }
- }
- else
- index = -1;
return index;
}
gtk_action_bar_pack_start (GtkActionBar *action_bar,
GtkWidget *child)
{
- gtk_container_add (GTK_CONTAINER (action_bar->start_box), child);
+ gtk_box_append (GTK_BOX (action_bar->start_box), child);
}
/**
GtkWidget *child)
{
if (gtk_widget_get_parent (child) == action_bar->start_box)
- gtk_container_remove (GTK_CONTAINER (action_bar->start_box), child);
+ gtk_box_remove (GTK_BOX (action_bar->start_box), child);
else if (gtk_widget_get_parent (child) == action_bar->end_box)
- gtk_container_remove (GTK_CONTAINER (action_bar->end_box), child);
+ gtk_box_remove (GTK_BOX (action_bar->end_box), child);
else if (child == gtk_center_box_get_center_widget (GTK_CENTER_BOX (action_bar->center_box)))
gtk_center_box_set_center_widget (GTK_CENTER_BOX (action_bar->center_box), NULL);
else
/* Need to build the appchooser widget after, because of the content-type construct-only property */
self->app_chooser_widget = gtk_app_chooser_widget_new (self->content_type);
gtk_widget_set_vexpand (self->app_chooser_widget, TRUE);
- gtk_container_add (GTK_CONTAINER (self->inner_box), self->app_chooser_widget);
+ gtk_box_append (GTK_BOX (self->inner_box), self->app_chooser_widget);
g_signal_connect (self->app_chooser_widget, "application-selected",
G_CALLBACK (widget_application_selected_cb), self);
G_CALLBACK (widget_notify_for_button_cb), self);
/* Add the custom button to the new appchooser */
- gtk_container_add (GTK_CONTAINER (self->inner_box),
+ gtk_box_append (GTK_BOX (self->inner_box),
self->show_more_button);
- gtk_container_add (GTK_CONTAINER (self->inner_box),
+ gtk_box_append (GTK_BOX (self->inner_box),
self->software_button);
info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self->app_chooser_widget));
static void
add_action_widgets (GtkAssistant *assistant)
{
- GList *children;
- GList *l;
+ GList *children, *l;
+ GtkWidget *child;
if (assistant->use_header_bar)
{
- children = gtk_container_get_children (GTK_CONTAINER (assistant->action_area));
+ children = NULL;
+ for (child = gtk_widget_get_last_child (assistant->action_area);
+ child != NULL;
+ child = gtk_widget_get_prev_sibling (child))
+ children = g_list_prepend (children, child);
for (l = children; l != NULL; l = l->next)
{
- GtkWidget *child = l->data;
gboolean has_default;
+ child = l->data;
has_default = gtk_widget_has_default (child);
g_object_ref (child);
- gtk_container_remove (GTK_CONTAINER (assistant->action_area), child);
+ gtk_box_remove (GTK_BOX (assistant->action_area), child);
add_to_header_bar (assistant, child);
g_object_unref (child);
gtk_size_group_remove_widget (assistant->title_size_group, page_info->regular_title);
gtk_size_group_remove_widget (assistant->title_size_group, page_info->current_title);
- gtk_container_remove (GTK_CONTAINER (assistant->sidebar), page_info->regular_title);
- gtk_container_remove (GTK_CONTAINER (assistant->sidebar), page_info->current_title);
+ gtk_box_remove (GTK_BOX (assistant->sidebar), page_info->regular_title);
+ gtk_box_remove (GTK_BOX (assistant->sidebar), page_info->current_title);
assistant->pages = g_list_remove_link (assistant->pages, element);
assistant->visited_pages = g_slist_remove_all (assistant->visited_pages, page_info);
if (alternative_button_order (assistant))
{
GList *buttons, *l;
+ GtkWidget *child;
- /* Reverse the action area children for the alternative button order setting */
- buttons = gtk_container_get_children (GTK_CONTAINER (assistant->action_area));
+ buttons = NULL;
+ for (child = gtk_widget_get_last_child (assistant->action_area);
+ child != NULL;
+ child = gtk_widget_get_prev_sibling (child))
+ buttons = g_list_prepend (buttons, child);
for (l = buttons; l; l = l->next)
gtk_box_reorder_child_after (GTK_BOX (assistant->action_area), GTK_WIDGET (l->data), NULL);
{
gtk_widget_set_valign (child, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (assistant->action_area), child);
+ gtk_box_append (GTK_BOX (assistant->action_area), child);
}
/**
update_actions_size (assistant);
}
- gtk_container_remove (GTK_CONTAINER (assistant->action_area), child);
+ gtk_box_remove (GTK_BOX (assistant->action_area), child);
}
/**
calendar->arrow_widgets[3] = gtk_button_new_from_icon_name ("pan-end-symbolic");
g_signal_connect_swapped (calendar->arrow_widgets[3], "clicked", G_CALLBACK (calendar_set_year_next), calendar);
- gtk_container_add (GTK_CONTAINER (calendar->header_box), calendar->arrow_widgets[0]);
- gtk_container_add (GTK_CONTAINER (calendar->header_box), calendar->month_name_stack);
- gtk_container_add (GTK_CONTAINER (calendar->header_box), calendar->arrow_widgets[1]);
- gtk_container_add (GTK_CONTAINER (calendar->header_box), calendar->arrow_widgets[2]);
- gtk_container_add (GTK_CONTAINER (calendar->header_box), calendar->year_label);
- gtk_container_add (GTK_CONTAINER (calendar->header_box), calendar->arrow_widgets[3]);
+ gtk_box_append (GTK_BOX (calendar->header_box), calendar->arrow_widgets[0]);
+ gtk_box_append (GTK_BOX (calendar->header_box), calendar->month_name_stack);
+ gtk_box_append (GTK_BOX (calendar->header_box), calendar->arrow_widgets[1]);
+ gtk_box_append (GTK_BOX (calendar->header_box), calendar->arrow_widgets[2]);
+ gtk_box_append (GTK_BOX (calendar->header_box), calendar->year_label);
+ gtk_box_append (GTK_BOX (calendar->header_box), calendar->arrow_widgets[3]);
gtk_widget_set_parent (calendar->header_box, GTK_WIDGET (calendar));
GVariantBuilder builder;
GVariant *variant;
GdkRGBA color;
- GList *children, *l;
GtkWidget *child;
+ gboolean first;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(dddd)"));
- children = gtk_container_get_children (GTK_CONTAINER (cc->custom));
- for (l = g_list_nth (children, 1); l != NULL; l = l->next)
+ for (child = gtk_widget_get_first_child (cc->custom), first = TRUE;
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child), first = FALSE)
{
- child = l->data;
+ if (first)
+ continue;
+
if (gtk_color_swatch_get_rgba (GTK_COLOR_SWATCH (child), &color))
{
double red, green, blue, alpha;
variant = g_variant_builder_end (&builder);
g_settings_set_value (cc->settings, "custom-colors", variant);
-
- g_list_free (children);
}
static void
gtk_color_chooser_widget_set_use_alpha (GtkColorChooserWidget *cc,
gboolean use_alpha)
{
- GList *palettes, *p;
GtkWidget *child;
GtkWidget *grid;
cc->use_alpha = use_alpha;
gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (cc->editor), use_alpha);
- palettes = gtk_container_get_children (GTK_CONTAINER (cc->palette));
- for (p = palettes; p; p = p->next)
+ for (grid = gtk_widget_get_first_child (cc->palette);
+ grid != NULL;
+ grid = gtk_widget_get_next_sibling (grid))
{
- grid = p->data;
-
for (child = gtk_widget_get_first_child (grid);
child != NULL;
child = gtk_widget_get_next_sibling (child))
gtk_color_swatch_set_use_alpha (GTK_COLOR_SWATCH (child), use_alpha);
}
}
- g_list_free (palettes);
gtk_widget_queue_draw (GTK_WIDGET (cc));
g_object_notify (G_OBJECT (cc), "use-alpha");
widget = l->data;
if (widget == cc->custom_label || widget == cc->custom)
continue;
- gtk_container_remove (GTK_CONTAINER (cc->palette), widget);
+ gtk_box_remove (GTK_BOX (cc->palette), widget);
}
g_list_free (children);
}
gtk_widget_set_margin_bottom (grid, 12);
gtk_grid_set_row_spacing (GTK_GRID (grid), 2);
gtk_grid_set_column_spacing (GTK_GRID (grid), 4);
- gtk_container_add (GTK_CONTAINER (cc->palette), grid);
+ gtk_box_append (GTK_BOX (cc->palette), grid);
left = 0;
right = colors_per_line - 1;
/* translators: label for the custom section in the color chooser */
cc->custom_label = label = gtk_label_new (_("Custom"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
- gtk_container_add (GTK_CONTAINER (cc->palette), label);
+ gtk_box_append (GTK_BOX (cc->palette), label);
cc->custom = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
g_object_set (box, "margin-top", 12, NULL);
- gtk_container_add (GTK_CONTAINER (cc->palette), box);
+ gtk_box_append (GTK_BOX (cc->palette), box);
cc->button = button = gtk_color_swatch_new ();
gtk_widget_set_name (button, "add-color-button");
connect_button_signals (button, cc);
gtk_color_swatch_set_icon (GTK_COLOR_SWATCH (button), "list-add-symbolic");
gtk_color_swatch_set_selectable (GTK_COLOR_SWATCH (button), FALSE);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
cc->settings = g_settings_new ("org.gtk.gtk4.Settings.ColorChooser");
variant = g_settings_get_value (cc->settings, I_("custom-colors"));
g_free (text);
g_free (name);
connect_custom_signals (p, cc);
- gtk_container_add (GTK_CONTAINER (box), p);
+ gtk_box_append (GTK_BOX (box), p);
if (i == 8)
break;
add_custom_color (GtkColorChooserWidget *cc,
const GdkRGBA *color)
{
- GtkWidget *p;
+ GtkWidget *widget;
GList *children;
+ GtkWidget *p;
+
+ children = NULL;
+ for (widget = gtk_widget_get_first_child (cc->custom);
+ widget != NULL;
+ widget = gtk_widget_get_next_sibling (widget))
+ children = g_list_prepend (children, widget);
- children = gtk_container_get_children (GTK_CONTAINER (cc->custom));
if (g_list_length (children) >= 9)
{
GtkWidget *last = gtk_widget_get_last_child (cc->custom);
if (last == (GtkWidget *)cc->current)
cc->current = NULL;
- gtk_container_remove (GTK_CONTAINER (cc->custom), last);
+ gtk_box_remove (GTK_BOX (cc->custom), last);
}
g_list_free (children);
const GdkRGBA *color)
{
GtkColorChooserWidget *cc = GTK_COLOR_CHOOSER_WIDGET (chooser);
- GList *palettes, *p;
GtkWidget *swatch;
GtkWidget *w;
+
GdkRGBA c;
- palettes = gtk_container_get_children (GTK_CONTAINER (cc->palette));
- for (p = palettes; p; p = p->next)
+ for (w = gtk_widget_get_first_child (cc->palette);
+ w != NULL;
+ w = gtk_widget_get_next_sibling (w))
{
- w = p->data;
if (!GTK_IS_GRID (w) && !GTK_IS_BOX (w))
continue;
if (gdk_rgba_equal (color, &c))
{
select_swatch (cc, GTK_COLOR_SWATCH (swatch));
- g_list_free (palettes);
return;
}
}
}
- g_list_free (palettes);
add_custom_color (cc, color);
}
combo_box);
}
- gtk_container_remove (GTK_CONTAINER (priv->box), widget);
+ gtk_box_remove (GTK_BOX (priv->box), widget);
priv->child = NULL;
else
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (button), 1);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
gtk_widget_show (button);
data->spin_button = button;
label = gtk_label_new (_("mm"));
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
gtk_widget_show (label);
gtk_label_set_mnemonic_widget (GTK_LABEL (mnemonic_label), button);
gtk_widget_set_margin_end (hbox, 20);
gtk_widget_set_margin_top (hbox, 20);
gtk_widget_set_margin_bottom (hbox, 20);
- gtk_container_add (GTK_CONTAINER (content_area), hbox);
+ gtk_box_append (GTK_BOX (content_area), hbox);
gtk_widget_show (hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
gtk_widget_show (vbox);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (scrolled), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), scrolled);
+ gtk_box_append (GTK_BOX (vbox), scrolled);
gtk_widget_show (scrolled);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->custom_paper_list));
gtk_widget_add_css_class (toolbar, "linked");
- gtk_container_add (GTK_CONTAINER (vbox), toolbar);
+ gtk_box_append (GTK_BOX (vbox), toolbar);
button = gtk_button_new_from_icon_name ("list-add-symbolic");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (add_custom_paper), dialog);
- gtk_container_add (GTK_CONTAINER (toolbar), button);
+ gtk_box_append (GTK_BOX (toolbar), button);
button = gtk_button_new_from_icon_name ("list-remove-symbolic");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (remove_custom_paper), dialog);
- gtk_container_add (GTK_CONTAINER (toolbar), button);
+ gtk_box_append (GTK_BOX (toolbar), button);
user_units = _gtk_print_get_default_user_units ();
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
priv->values_box = vbox;
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
gtk_widget_show (vbox);
grid = gtk_grid_new ();
frame = wrap_in_frame (_("Paper Size"), grid);
gtk_widget_show (grid);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
gtk_widget_show (frame);
grid = gtk_grid_new ();
NULL, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
- gtk_container_add (GTK_CONTAINER (hbox), combo);
+ gtk_box_append (GTK_BOX (hbox), combo);
gtk_widget_show (combo);
g_signal_connect_swapped (combo, "changed",
frame = wrap_in_frame (_("Paper Margins"), grid);
gtk_widget_show (grid);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
gtk_widget_show (frame);
update_custom_widgets_from_list (dialog);
*
* // Add the label, and show everything we’ve added
*
- * gtk_container_add (GTK_CONTAINER (content_area), label);
+ * gtk_box_append (GTK_BOX (content_area), label);
* gtk_widget_show (dialog);
* }
* ]|
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
gtk_widget_set_valign (child, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (priv->action_area), child);
+ gtk_box_append (GTK_BOX (priv->action_area), child);
apply_response_for_action_area (dialog, child, response_id);
}
if (priv->use_header_bar)
{
GList *children, *l;
+ GtkWidget *child;
+
+ children = NULL;
+ for (child = gtk_widget_get_first_child (priv->action_area);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ children = g_list_append (children, child);
- children = gtk_container_get_children (GTK_CONTAINER (priv->action_area));
for (l = children; l != NULL; l = l->next)
{
- GtkWidget *child = l->data;
gboolean has_default;
ResponseData *rd;
gint response_id;
+ child = l->data;
+
has_default = gtk_widget_has_default (child);
rd = get_response_data (child, FALSE);
response_id = rd ? rd->response_id : GTK_RESPONSE_NONE;
g_object_ref (child);
- gtk_container_remove (GTK_CONTAINER (priv->action_area), child);
+ gtk_box_remove (GTK_BOX (priv->action_area), child);
add_to_header_bar (dialog, child, response_id);
g_object_unref (child);
get_action_children (GtkDialog *dialog)
{
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
+ GtkWidget *parent;
+ GtkWidget *child;
GList *children;
if (priv->constructed && priv->use_header_bar)
- {
- GtkWidget *child;
-
- children = NULL;
- for (child = gtk_widget_get_first_child (priv->headerbar);
- child != NULL;
- child = gtk_widget_get_next_sibling (child))
- children = g_list_append (children, child);
- }
+ parent = priv->headerbar;
else
- children = gtk_container_get_children (GTK_CONTAINER (priv->action_area));
+ parent = priv->action_area;
+
+ children = NULL;
+ for (child = gtk_widget_get_first_child (parent);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ children = g_list_prepend (children, child);
- return children;
+ return g_list_reverse (children);
}
/* A far too tricky heuristic for getting the right initial
GList *children, *l;
int i;
GVariantBuilder builder;
+ GtkWidget *child;
g_variant_ref (item);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a((auss)u)"));
g_variant_builder_add (&builder, "(@(auss)u)", item, modifier);
- children = gtk_container_get_children (GTK_CONTAINER (chooser->recent.box));
+ children = NULL;
+ for (child = gtk_widget_get_last_child (chooser->recent.box);
+ child != NULL;
+ child = gtk_widget_get_prev_sibling (child))
+ children = g_list_prepend (children, child);
+
for (l = children, i = 1; l; l = l->next, i++)
{
GVariant *item2 = g_object_get_data (G_OBJECT (l->data), "emoji-data");
if (modifier == modifier2 && g_variant_equal (item, item2))
{
- gtk_container_remove (GTK_CONTAINER (chooser->recent.box), l->data);
+ gtk_flow_box_remove (GTK_FLOW_BOX (chooser->recent.box), l->data);
i--;
continue;
}
if (i >= MAX_RECENT)
{
- gtk_container_remove (GTK_CONTAINER (chooser->recent.box), l->data);
+ gtk_flow_box_remove (GTK_FLOW_BOX (chooser->recent.box), l->data);
continue;
}
gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (box), GTK_SELECTION_NONE);
g_object_set (box, "accept-unpaired-release", TRUE, NULL);
gtk_popover_set_child (GTK_POPOVER (popover), view);
- gtk_container_add (GTK_CONTAINER (view), box);
+ gtk_box_append (GTK_BOX (view), box);
g_signal_connect (box, "child-activated", G_CALLBACK (emoji_activated), parent_popover);
if (modifier != 0)
g_object_set_data (G_OBJECT (child), "modifier", GUINT_TO_POINTER (modifier));
- gtk_container_add (GTK_CONTAINER (child), label);
+ gtk_box_append (GTK_BOX (child), label);
gtk_flow_box_insert (GTK_FLOW_BOX (box), child, -1);
}
child = g_object_new (GTK_TYPE_LIST_BOX_ROW, "css-name", "emoji-completion-row", NULL);
gtk_widget_set_focus_on_click (child, FALSE);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (child), box);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (child), box);
+ gtk_box_append (GTK_BOX (box), label);
g_object_set_data (G_OBJECT (child), "base", label);
stack = gtk_stack_new ();
gtk_stack_set_hhomogeneous (GTK_STACK (stack), TRUE);
gtk_stack_set_vhomogeneous (GTK_STACK (stack), TRUE);
gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT);
- gtk_container_add (GTK_CONTAINER (box), stack);
+ gtk_box_append (GTK_BOX (box), stack);
g_object_set_data (G_OBJECT (child), "stack", stack);
g_variant_get_child (emoji_data, 2, "&s", &shortname);
const char *text,
guint offset)
{
- GtkWidget *child;
guint n_matches;
guint n_added;
GVariantIter iter;
GVariant *item;
+ GtkWidget *child;
if (completion->text != text)
{
completion->offset = offset;
while ((child = gtk_widget_get_first_child (completion->list)))
- gtk_container_remove (GTK_CONTAINER (completion->list), child);
+ gtk_list_box_remove (GTK_LIST_BOX (completion->list), child);
completion->active = NULL;
priv->tree_view);
gtk_widget_set_hexpand (priv->scrolled_window, TRUE);
gtk_widget_set_vexpand (priv->scrolled_window, TRUE);
- gtk_container_add (GTK_CONTAINER (priv->vbox), priv->scrolled_window);
+ gtk_box_append (GTK_BOX (priv->vbox), priv->scrolled_window);
/* we don't want to see the action treeview when no actions have
* been inserted, so we pack the action treeview after the first
path, NULL, FALSE);
gtk_tree_path_free (path);
- gtk_container_add (GTK_CONTAINER (completion->priv->vbox),
+ gtk_box_append (GTK_BOX (completion->priv->vbox),
completion->priv->action_view);
gtk_widget_show (completion->priv->action_view);
}
* A #GtkExpander allows the user to hide or show its child by clicking
* on an expander triangle similar to the triangles used in a #GtkTreeView.
*
- * Normally you use an expander as you would use a descendant
- * of #GtkBin; you create the child widget and use gtk_container_add()
- * to add it to the expander. When the expander is toggled, it will take
- * care of showing and hiding the child automatically.
+ * Normally you use an expander as you would use a frame; you create
+ * the child widget and use gtk_expander_set_child() to add it to the
+ * expander. When the expander is toggled, it will take care of showing
+ * and hiding the child automatically.
*
* # Special Usage
*
gtk_widget_set_parent (expander->box, GTK_WIDGET (expander));
expander->title_widget = g_object_new (GTK_TYPE_BOX,
- "css-name", "title",
- NULL);
- gtk_container_add (GTK_CONTAINER (expander->box), expander->title_widget);
+ "css-name", "title",
+ NULL);
+ gtk_box_append (GTK_BOX (expander->box), expander->title_widget);
expander->arrow_widget = gtk_builtin_icon_new ("expander");
gtk_widget_add_css_class (expander->arrow_widget, GTK_STYLE_CLASS_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (expander->title_widget), expander->arrow_widget);
+ gtk_box_append (GTK_BOX (expander->title_widget), expander->arrow_widget);
controller = gtk_drop_controller_motion_new ();
g_signal_connect (controller, "enter", G_CALLBACK (gtk_expander_drag_enter), expander);
{
if (expander->expanded)
{
- gtk_container_add (GTK_CONTAINER (expander->box), child);
+ gtk_box_append (GTK_BOX (expander->box), child);
g_object_unref (expander->child);
}
else
{
g_object_ref (expander->child);
- gtk_container_remove (GTK_CONTAINER (expander->box), child);
+ gtk_box_remove (GTK_BOX (expander->box), child);
}
gtk_expander_resize_toplevel (expander);
}
return;
if (expander->label_widget)
- {
- gtk_container_remove (GTK_CONTAINER (expander->title_widget), expander->label_widget);
- }
+ gtk_box_remove (GTK_BOX (expander->title_widget), expander->label_widget);
expander->label_widget = label_widget;
widget = GTK_WIDGET (expander);
{
expander->label_widget = label_widget;
- gtk_container_add (GTK_CONTAINER (expander->title_widget), label_widget);
+ gtk_box_append (GTK_BOX (expander->title_widget), label_widget);
}
if (gtk_widget_get_visible (widget))
if (expander->child)
{
- gtk_container_remove (GTK_CONTAINER (expander->box), expander->child);
+ gtk_box_remove (GTK_BOX (expander->box), expander->child);
if (!expander->expanded)
g_object_unref (expander->child);
}
if (expander->child)
{
if (expander->expanded)
- gtk_container_add (GTK_CONTAINER (expander->box), expander->child);
+ gtk_box_append (GTK_BOX (expander->box), expander->child);
else
{
if (g_object_is_floating (expander->child))
icon = gtk_image_new_from_icon_name ("document-open-symbolic");
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_valign (button->image, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (box), button->image);
+ gtk_box_append (GTK_BOX (box), button->image);
gtk_widget_set_valign (button->label, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (box), button->label);
+ gtk_box_append (GTK_BOX (box), button->label);
gtk_widget_set_valign (icon, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (box), icon);
+ gtk_box_append (GTK_BOX (box), icon);
gtk_button_set_child (GTK_BUTTON (button->button), box);
gtk_widget_set_parent (button->button, GTK_WIDGET (button));
g_object_set (label, "margin-start", 6, "margin-end", 6, NULL);
g_object_set (entry, "margin-start", 6, "margin-end", 6, NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
- gtk_container_add (GTK_CONTAINER (box), label);
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), label);
+ gtk_box_append (GTK_BOX (box), entry);
gtk_header_bar_set_title_widget (GTK_HEADER_BAR (header), box);
gtk_file_chooser_widget_set_save_entry (GTK_FILE_CHOOSER_WIDGET (priv->widget), entry);
gtk_widget_add_css_class (vbox, "search-bar");
impl->save_widgets_table = gtk_grid_new ();
- gtk_container_add (GTK_CONTAINER (vbox), impl->save_widgets_table);
+ gtk_box_append (GTK_BOX (vbox), impl->save_widgets_table);
gtk_grid_set_row_spacing (GTK_GRID (impl->save_widgets_table), 12);
gtk_grid_set_column_spacing (GTK_GRID (impl->save_widgets_table), 12);
if (impl->save_widgets == NULL)
return;
- gtk_container_remove (GTK_CONTAINER (impl->box), impl->save_widgets);
+ gtk_box_remove (GTK_BOX (impl->box), impl->save_widgets);
impl->save_widgets = NULL;
impl->save_widgets_table = NULL;
impl->location_entry = NULL;
static void
location_switch_to_path_bar (GtkFileChooserWidget *impl)
{
- if (impl->location_entry)
- {
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (impl->location_entry)),
- impl->location_entry);
- impl->location_entry = NULL;
- }
-
+ g_clear_pointer (&impl->location_entry, gtk_widget_unparent);
gtk_stack_set_visible_child_name (GTK_STACK (impl->browse_header_stack), "pathbar");
}
if (!impl->location_entry)
{
location_entry_create (impl);
- gtk_container_add (GTK_CONTAINER (impl->location_entry_box), impl->location_entry);
+ gtk_box_append (GTK_BOX (impl->location_entry_box), impl->location_entry);
}
_gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), impl->current_folder);
if (impl->extra_widget)
{
- gtk_container_remove (GTK_CONTAINER (impl->extra_align), impl->extra_widget);
+ gtk_box_remove (GTK_BOX (impl->extra_align), impl->extra_widget);
g_object_unref (impl->extra_widget);
}
impl->extra_widget = extra_widget;
if (impl->extra_widget)
{
- gtk_container_add (GTK_CONTAINER (impl->extra_align), impl->extra_widget);
+ gtk_box_append (GTK_BOX (impl->extra_align), impl->extra_widget);
gtk_widget_show (impl->extra_align);
}
else
int i;
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new (label));
+ gtk_box_append (GTK_BOX (box), gtk_label_new (label));
combo = gtk_combo_box_text_new ();
g_hash_table_insert (impl->choices, g_strdup (id), combo);
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
for (i = 0; options[i]; i++)
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo),
widget = check;
}
- gtk_container_add (GTK_CONTAINER (impl->choice_box), widget);
+ gtk_box_append (GTK_BOX (impl->choice_box), widget);
}
static void
widget = (GtkWidget *)g_hash_table_lookup (impl->choices, id);
g_hash_table_remove (impl->choices, id);
- gtk_container_remove (GTK_CONTAINER (impl->choice_box), widget);
+ gtk_box_remove (GTK_BOX (impl->choice_box), widget);
if (g_hash_table_size (impl->choices) == 0)
{
font_button->font_size_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), font_button->font_label);
+ gtk_box_append (GTK_BOX (box), font_button->font_label);
- gtk_container_add (GTK_CONTAINER (font_button->font_size_box), gtk_separator_new (GTK_ORIENTATION_VERTICAL));
- gtk_container_add (GTK_CONTAINER (font_button->font_size_box), font_button->size_label);
- gtk_container_add (GTK_CONTAINER (box), font_button->font_size_box);
+ gtk_box_append (GTK_BOX (font_button->font_size_box), gtk_separator_new (GTK_ORIENTATION_VERTICAL));
+ gtk_box_append (GTK_BOX (font_button->font_size_box), font_button->size_label);
+ gtk_box_append (GTK_BOX (box), font_button->font_size_box);
gtk_button_set_child (GTK_BUTTON (font_button->button), box);
gtk_widget_set_parent (font_button->button, GTK_WIDGET (font_button));
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
- gtk_container_add (GTK_CONTAINER (group), label);
+ gtk_box_append (GTK_BOX (group), label);
for (i = 0; tags[i]; i++)
{
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_set_homogeneous (GTK_BOX (box), TRUE);
- gtk_container_add (GTK_CONTAINER (box), feat);
- gtk_container_add (GTK_CONTAINER (box), example);
- gtk_container_add (GTK_CONTAINER (group), box);
+ gtk_box_append (GTK_BOX (box), feat);
+ gtk_box_append (GTK_BOX (box), example);
+ gtk_box_append (GTK_BOX (group), box);
item = g_new (FeatureItem, 1);
item->name = tags[i];
fontchooser->feature_items = g_list_prepend (fontchooser->feature_items, item);
}
- gtk_container_add (GTK_CONTAINER (fontchooser->feature_box), group);
+ gtk_box_append (GTK_BOX (fontchooser->feature_box), group);
}
static void
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
- gtk_container_add (GTK_CONTAINER (group), label);
+ gtk_box_append (GTK_BOX (group), label);
for (i = 0; tags[i]; i++)
{
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_set_homogeneous (GTK_BOX (box), TRUE);
- gtk_container_add (GTK_CONTAINER (box), feat);
- gtk_container_add (GTK_CONTAINER (box), example);
- gtk_container_add (GTK_CONTAINER (group), box);
+ gtk_box_append (GTK_BOX (box), feat);
+ gtk_box_append (GTK_BOX (box), example);
+ gtk_box_append (GTK_BOX (group), box);
item = g_new (FeatureItem, 1);
item->name = tags[i];
fontchooser->feature_items = g_list_prepend (fontchooser->feature_items, item);
}
- gtk_container_add (GTK_CONTAINER (fontchooser->feature_box), group);
+ gtk_box_append (GTK_BOX (fontchooser->feature_box), group);
}
static void
*
* Children are added using gtk_grid_attach(). They can span multiple
* rows or columns. It is also possible to add a child next to an
- * existing child, using gtk_grid_attach_next_to(). The behaviour of
- * GtkGrid when several children occupy the same grid cell is undefined.
- *
- * GtkGrid can be used like a #GtkBox by just using gtk_container_add(),
- * which will place children next to each other in the direction determined
- * by the #GtkOrientable:orientation property. However, if all you want is a
- * single row or column, then #GtkBox is the preferred widget.
+ * existing child, using gtk_grid_attach_next_to(). To remove a child
+ * from the grid, use gtk_grid_remove(). The behaviour of GtkGrid when
+ * several children occupy the same grid cell is undefined.
*
* # CSS nodes
*
if (height <= 0)
{
- gtk_container_remove (GTK_CONTAINER (grid), child);
+ gtk_grid_remove (grid, child);
}
else
{
if (width <= 0)
{
- gtk_container_remove (GTK_CONTAINER (grid), child);
+ gtk_grid_remove (grid, child);
}
else
{
g_object_bind_property (controls, "empty",
controls, "visible",
G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN);
- gtk_container_add (GTK_CONTAINER (priv->start_box), controls);
+ gtk_box_append (GTK_BOX (priv->start_box), controls);
priv->start_window_controls = controls;
controls = gtk_window_controls_new (GTK_PACK_END);
g_object_bind_property (controls, "empty",
controls, "visible",
G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN);
- gtk_container_add (GTK_CONTAINER (priv->end_box), controls);
+ gtk_box_append (GTK_BOX (priv->end_box), controls);
priv->end_window_controls = controls;
}
if (pack_type == GTK_PACK_START)
{
- gtk_container_add (GTK_CONTAINER (priv->start_box), widget);
+ gtk_box_append (GTK_BOX (priv->start_box), widget);
}
else if (pack_type == GTK_PACK_END)
{
- gtk_container_add (GTK_CONTAINER (priv->end_box), widget);
+ gtk_box_append (GTK_BOX (priv->end_box), widget);
gtk_box_reorder_child_after (GTK_BOX (priv->end_box), widget, NULL);
}
if (parent == priv->start_box)
{
- gtk_container_remove (GTK_CONTAINER (priv->start_box), child);
+ gtk_box_remove (GTK_BOX (priv->start_box), child);
removed = TRUE;
}
else if (parent == priv->end_box)
{
- gtk_container_remove (GTK_CONTAINER (priv->end_box), child);
+ gtk_box_remove (GTK_BOX (priv->end_box), child);
removed = TRUE;
}
else if (parent == priv->center_box)
find_button (GtkInfoBar *info_bar,
gint response_id)
{
- GList *children, *list;
- GtkWidget *child = NULL;
+ GtkWidget *child;
- children = gtk_container_get_children (GTK_CONTAINER (info_bar->action_area));
-
- for (list = children; list; list = list->next)
+ for (child = gtk_widget_get_first_child (info_bar->action_area);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
{
- ResponseData *rd = get_response_data (list->data, FALSE);
+ ResponseData *rd = get_response_data (child, FALSE);
if (rd && rd->response_id == response_id)
- {
- child = list->data;
- break;
- }
+ return child;
}
- g_list_free (children);
-
- return child;
+ return NULL;
}
static void
info_bar->content_area = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_hexpand (info_bar->content_area, TRUE);
- gtk_container_add (GTK_CONTAINER (main_box), info_bar->content_area);
+ gtk_box_append (GTK_BOX (main_box), info_bar->content_area);
info_bar->action_area = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_halign (info_bar->action_area, GTK_ALIGN_END);
gtk_widget_set_valign (info_bar->action_area, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (main_box), info_bar->action_area);
+ gtk_box_append (GTK_BOX (main_box), info_bar->action_area);
info_bar->close_button = gtk_button_new_from_icon_name ("window-close-symbolic");
gtk_widget_hide (info_bar->close_button);
gtk_widget_set_valign (info_bar->close_button, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (info_bar->close_button, "close");
- gtk_container_add (GTK_CONTAINER (main_box), info_bar->close_button);
+ gtk_box_append (GTK_BOX (main_box), info_bar->close_button);
g_signal_connect (info_bar->close_button, "clicked",
G_CALLBACK (close_button_clicked_cb), info_bar);
else
g_warning ("Only 'activatable' widgets can be packed into the action area of a GtkInfoBar");
- gtk_container_add (GTK_CONTAINER (info_bar->action_area), child);
+ gtk_box_append (GTK_BOX (info_bar->action_area), child);
}
/**
clear_response_data (widget);
- gtk_container_remove (GTK_CONTAINER (info_bar->action_area), widget);
+ gtk_box_remove (GTK_BOX (info_bar->action_area), widget);
}
/**
gint response_id,
gboolean setting)
{
- GList *children, *list;
+ GtkWidget *child;
g_return_if_fail (GTK_IS_INFO_BAR (info_bar));
- children = gtk_container_get_children (GTK_CONTAINER (info_bar->action_area));
-
- for (list = children; list; list = list->next)
+ for (child = gtk_widget_get_first_child (info_bar->action_area);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
{
- GtkWidget *widget = list->data;
- ResponseData *rd = get_response_data (widget, FALSE);
+ ResponseData *rd = get_response_data (child, FALSE);
if (rd && rd->response_id == response_id)
- gtk_widget_set_sensitive (widget, setting);
+ gtk_widget_set_sensitive (child, setting);
}
- g_list_free (children);
-
if (response_id == info_bar->default_response)
update_default_response (info_bar, response_id, setting);
}
gtk_info_bar_set_default_response (GtkInfoBar *info_bar,
gint response_id)
{
- GList *children, *list;
+ GtkWidget *child;
+ GtkWidget *window;
gboolean sensitive = TRUE;
g_return_if_fail (GTK_IS_INFO_BAR (info_bar));
- children = gtk_container_get_children (GTK_CONTAINER (info_bar->action_area));
+ window = gtk_widget_get_ancestor (GTK_WIDGET (info_bar), GTK_TYPE_WINDOW);
- for (list = children; list; list = list->next)
+ for (child = gtk_widget_get_first_child (info_bar->action_area);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
{
- GtkWidget *widget = list->data;
- ResponseData *rd = get_response_data (widget, FALSE);
+ ResponseData *rd = get_response_data (child, FALSE);
if (rd && rd->response_id == response_id)
{
- GtkWidget *window;
-
- window = gtk_widget_get_ancestor (GTK_WIDGET (info_bar), GTK_TYPE_WINDOW);
- gtk_window_set_default_widget (GTK_WINDOW (window), widget);
- sensitive = gtk_widget_get_sensitive (widget);
+ gtk_window_set_default_widget (GTK_WINDOW (window), child);
+ sensitive = gtk_widget_get_sensitive (child);
+ break;
}
}
- g_list_free (children);
-
update_default_response (info_bar, response_id, sensitive);
}
if (!type && GTK_IS_WIDGET (child))
gtk_info_bar_add_child (GTK_INFO_BAR (info_bar), GTK_WIDGET (child));
else if (g_strcmp0 (type, "action") == 0)
- gtk_container_add (GTK_CONTAINER (info_bar->action_area), GTK_WIDGET (child));
+ gtk_box_append (GTK_BOX (info_bar->action_area), GTK_WIDGET (child));
else
parent_buildable_iface->add_child (buildable, builder, child, type);
}
g_return_if_fail (GTK_IS_INFO_BAR (info_bar));
g_return_if_fail (GTK_IS_WIDGET (widget));
- gtk_container_add (GTK_CONTAINER (info_bar->content_area), widget);
+ gtk_box_append (GTK_BOX (info_bar->content_area), widget);
}
/**
g_return_if_fail (GTK_IS_INFO_BAR (info_bar));
g_return_if_fail (GTK_IS_WIDGET (widget));
- gtk_container_remove (GTK_CONTAINER (info_bar->content_area), widget);
+ gtk_box_remove (GTK_BOX (info_bar->content_area), widget);
}
gtk_button_get_use_underline (GTK_BUTTON (menu_button->button)));
gtk_widget_set_hexpand (label_widget, TRUE);
image = gtk_image_new_from_icon_name ("pan-down-symbolic");
- gtk_container_add (GTK_CONTAINER (box), label_widget);
- gtk_container_add (GTK_CONTAINER (box), image);
+ gtk_box_append (GTK_BOX (box), label_widget);
+ gtk_box_append (GTK_BOX (box), image);
gtk_button_set_child (GTK_BUTTON (menu_button->button), box);
menu_button->label_widget = label_widget;
static GtkWidget * gtk_menu_section_box_new_section (GtkMenuTrackerItem *item,
GtkMenuSectionBox *parent);
-static void
-gtk_menu_section_box_sync_item (GtkWidget *widget,
- gpointer user_data)
-{
- MenuData *data = (MenuData *)user_data;
-
- if (GTK_IS_MENU_SECTION_BOX (widget))
- gtk_menu_section_box_sync_separators (GTK_MENU_SECTION_BOX (widget), data);
- else
- data->n_items++;
-}
-
/* We are trying to implement the following rules here:
*
* rule 1: never ever show separators for empty sections
gboolean has_label;
gboolean separator_condition;
gint n_items_before;
+ GtkWidget *child;
n_items_before = data->n_items;
previous_section_is_iconic = data->previous_is_iconic;
- gtk_container_foreach (GTK_CONTAINER (box->item_box), gtk_menu_section_box_sync_item, data);
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (box->item_box));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ {
+ if (GTK_IS_MENU_SECTION_BOX (child))
+ gtk_menu_section_box_sync_separators (GTK_MENU_SECTION_BOX (child), data);
+ else
+ data->n_items++;
+ }
is_not_empty_item = (data->n_items > n_items_before);
if (should_have_separator)
gtk_box_insert_child_after (GTK_BOX (box), box->separator, NULL);
else
- gtk_container_remove (GTK_CONTAINER (box), box->separator);
+ gtk_box_remove (GTK_BOX (box), box->separator);
}
static gboolean
GtkMenuSectionBox *box = user_data;
GtkMenuTrackerItem *item;
GtkWidget *widget;
- GList *children;
-
- children = gtk_container_get_children (GTK_CONTAINER (box->item_box));
+ int pos;
- widget = g_list_nth_data (children, position);
+ for (widget = gtk_widget_get_first_child (GTK_WIDGET (box->item_box)), pos = 0;
+ widget != NULL;
+ widget = gtk_widget_get_next_sibling (widget), pos++)
+ {
+ if (pos == position)
+ break;
+ }
item = g_object_get_data (G_OBJECT (widget), "GtkMenuTrackerItem");
if (gtk_menu_tracker_item_get_has_link (item, G_MENU_LINK_SUBMENU))
gtk_stack_remove (GTK_STACK (stack), subbox);
}
- gtk_container_remove (GTK_CONTAINER (box->item_box),
- g_list_nth_data (children, position));
- g_list_free (children);
+ gtk_box_remove (GTK_BOX (box->item_box), widget);
gtk_menu_section_box_schedule_separator_sync (box);
}
{
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
}
- gtk_container_add (GTK_CONTAINER (box->item_box), widget);
+ gtk_box_append (GTK_BOX (box->item_box), widget);
if (position == 0)
gtk_box_reorder_child_after (GTK_BOX (box->item_box), widget, NULL);
item_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
box->item_box = GTK_BOX (item_box);
- gtk_container_add (GTK_CONTAINER (box), item_box);
+ gtk_box_append (GTK_BOX (box), item_box);
gtk_widget_set_halign (GTK_WIDGET (item_box), GTK_ALIGN_FILL);
gtk_widget_set_halign (GTK_WIDGET (box), GTK_ALIGN_FILL);
}
gtk_widget_add_css_class (GTK_WIDGET (box->item_box), "inline-buttons");
spacer = gtk_builtin_icon_new ("none");
- gtk_container_add (GTK_CONTAINER (box->item_box), spacer);
+ gtk_box_append (GTK_BOX (box->item_box), spacer);
gtk_size_group_add_widget (box->indicators, spacer);
if (label != NULL)
gtk_widget_set_hexpand (title, TRUE);
gtk_widget_set_halign (title, GTK_ALIGN_START);
g_object_bind_property (item, "label", title, "label", G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (box->item_box), title);
+ gtk_box_append (GTK_BOX (box->item_box), title);
}
item_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box->item_box), item_box);
+ gtk_box_append (GTK_BOX (box->item_box), item_box);
box->item_box = GTK_BOX (item_box);
}
else if (hint && g_str_equal (hint, "circular-buttons"))
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_valign (separator, GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (separator, TRUE);
- gtk_container_add (GTK_CONTAINER (box->separator), separator);
+ gtk_box_append (GTK_BOX (box->separator), separator);
title = gtk_label_new (label);
g_object_bind_property (item, "label", title, "label", G_BINDING_SYNC_CREATE);
gtk_widget_set_halign (title, GTK_ALIGN_START);
gtk_label_set_xalign (GTK_LABEL (title), 0.0);
gtk_widget_add_css_class (title, GTK_STYLE_CLASS_TITLE);
- gtk_container_add (GTK_CONTAINER (box->separator), title);
+ gtk_box_append (GTK_BOX (box->separator), title);
}
else
{
gtk_widget_set_halign (label, GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_add_css_class (label, "title");
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
g_signal_connect_object (dialog, "notify::title", G_CALLBACK (update_title), label, 0);
gtk_window_set_titlebar (GTK_WINDOW (dialog), box);
gtk_widget_set_valign (self->start_indicator, GTK_ALIGN_CENTER);
update_start_indicator (self);
- gtk_container_add (GTK_CONTAINER (self->start_box), self->start_indicator);
+ gtk_box_append (GTK_BOX (self->start_box), self->start_indicator);
}
else if (start_name)
{
}
else if (self->start_indicator)
{
- gtk_container_remove (GTK_CONTAINER (self->start_box), self->start_indicator);
+ gtk_box_remove (GTK_BOX (self->start_box), self->start_indicator);
self->start_indicator = NULL;
}
{
if (self->start_indicator)
{
- gtk_container_remove (GTK_CONTAINER (self->start_box), self->start_indicator);
+ gtk_box_remove (GTK_BOX (self->start_box), self->start_indicator);
self->start_indicator = NULL;
}
g_clear_pointer (&self->end_indicator, gtk_widget_unparent);
/* Build contents */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
- gtk_container_add (GTK_CONTAINER (content_area), hbox);
+ gtk_box_append (GTK_BOX (content_area), hbox);
icon = gtk_image_new_from_icon_name ("dialog-password");
gtk_image_set_icon_size (GTK_IMAGE (icon), GTK_ICON_SIZE_LARGE);
gtk_widget_set_halign (icon, GTK_ALIGN_CENTER);
gtk_widget_set_valign (icon, GTK_ALIGN_START);
- gtk_container_add (GTK_CONTAINER (hbox), icon);
+ gtk_box_append (GTK_BOX (hbox), icon);
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
- gtk_container_add (GTK_CONTAINER (hbox), main_vbox);
+ gtk_box_append (GTK_BOX (hbox), main_vbox);
secondary = strstr (message, "\n");
if (secondary != NULL)
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
- gtk_container_add (GTK_CONTAINER (main_vbox), GTK_WIDGET (label));
+ gtk_box_append (GTK_BOX (main_vbox), GTK_WIDGET (label));
g_free (primary);
attrs = pango_attr_list_new ();
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
- gtk_container_add (GTK_CONTAINER (main_vbox), GTK_WIDGET (label));
+ gtk_box_append (GTK_BOX (main_vbox), GTK_WIDGET (label));
}
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 12);
gtk_grid_set_column_spacing (GTK_GRID (grid), 12);
gtk_widget_set_margin_bottom (grid, 12);
- gtk_container_add (GTK_CONTAINER (main_vbox), grid);
+ gtk_box_append (GTK_BOX (main_vbox), grid);
can_anonymous = priv->ask_flags & G_ASK_PASSWORD_ANONYMOUS_SUPPORTED;
gtk_grid_attach (GTK_GRID (grid), anon_box, 1, rows++, 1, 1);
choice = gtk_radio_button_new_with_mnemonic (NULL, _("_Anonymous"));
- gtk_container_add (GTK_CONTAINER (anon_box),
+ gtk_box_append (GTK_BOX (anon_box),
choice);
g_signal_connect (choice, "toggled",
G_CALLBACK (pw_dialog_anonymous_toggled), operation);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));
choice = gtk_radio_button_new_with_mnemonic (group, _("Registered U_ser"));
- gtk_container_add (GTK_CONTAINER (anon_box),
+ gtk_box_append (GTK_BOX (anon_box),
choice);
g_signal_connect (choice, "toggled",
G_CALLBACK (pw_dialog_anonymous_toggled), operation);
priv->user_widgets = g_list_prepend (priv->user_widgets, volume_type_box);
priv->tcrypt_hidden_toggle = gtk_check_button_new_with_mnemonic (_("_Hidden"));
- gtk_container_add (GTK_CONTAINER (volume_type_box), priv->tcrypt_hidden_toggle);
+ gtk_box_append (GTK_BOX (volume_type_box), priv->tcrypt_hidden_toggle);
priv->tcrypt_system_toggle = gtk_check_button_new_with_mnemonic (_("_Windows system"));
- gtk_container_add (GTK_CONTAINER (volume_type_box), priv->tcrypt_system_toggle);
+ gtk_box_append (GTK_BOX (volume_type_box), priv->tcrypt_system_toggle);
priv->pim_entry = table_add_entry (operation, rows++, _("_PIM"), NULL, operation);
}
priv->user_widgets = g_list_prepend (priv->user_widgets, remember_box);
label = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (remember_box), label);
+ gtk_box_append (GTK_BOX (remember_box), label);
password_save = g_mount_operation_get_password_save (G_MOUNT_OPERATION (operation));
priv->password_save = password_save;
GINT_TO_POINTER (G_PASSWORD_SAVE_NEVER));
g_signal_connect (choice, "toggled",
G_CALLBACK (remember_button_toggled), operation);
- gtk_container_add (GTK_CONTAINER (remember_box), choice);
+ gtk_box_append (GTK_BOX (remember_box), choice);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));
choice = gtk_radio_button_new_with_mnemonic (group, _("Remember password until you _logout"));
GINT_TO_POINTER (G_PASSWORD_SAVE_FOR_SESSION));
g_signal_connect (choice, "toggled",
G_CALLBACK (remember_button_toggled), operation);
- gtk_container_add (GTK_CONTAINER (remember_box), choice);
+ gtk_box_append (GTK_BOX (remember_box), choice);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));
choice = gtk_radio_button_new_with_mnemonic (group, _("Remember _forever"));
GINT_TO_POINTER (G_PASSWORD_SAVE_PERMANENTLY));
g_signal_connect (choice, "toggled",
G_CALLBACK (remember_button_toggled), operation);
- gtk_container_add (GTK_CONTAINER (remember_box), choice);
+ gtk_box_append (GTK_BOX (remember_box), choice);
}
g_signal_connect (G_OBJECT (dialog), "response",
g_signal_connect (item, "clicked",
G_CALLBACK (on_end_process_activated),
op);
- gtk_container_add (GTK_CONTAINER (menu), item);
+ gtk_box_append (GTK_BOX (menu), item);
if (event && gdk_event_triggers_context_menu (event))
{
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
- gtk_container_add (GTK_CONTAINER (content_area), vbox);
+ gtk_box_append (GTK_BOX (content_area), vbox);
if (secondary != NULL)
s = g_strdup_printf ("<big><b>%s</b></big>\n\n%s", primary, secondary);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), s);
g_free (s);
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
/* First count the items in the list then
* add the buttons in reverse order
gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (scrolled_window), TRUE);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled_window), tree_view);
- gtk_container_add (GTK_CONTAINER (vbox), scrolled_window);
+ gtk_box_append (GTK_BOX (vbox), scrolled_window);
controller = gtk_shortcut_controller_new ();
trigger = gtk_alternative_trigger_new (gtk_keyval_trigger_new (GDK_KEY_F10, GDK_SHIFT_MASK),
GtkNotebookPage *page);
static void gtk_notebook_menu_item_recreate (GtkNotebook *notebook,
GList *list);
-static void gtk_notebook_menu_label_unparent (GtkWidget *widget,
- gpointer data);
+static void gtk_notebook_menu_label_unparent (GtkWidget *widget);
static void gtk_notebook_update_tab_pos (GtkNotebook *notebook);
(GtkGizmoFocusFunc)gtk_widget_focus_self,
(GtkGizmoGrabFocusFunc)gtk_widget_grab_focus_self);
gtk_widget_set_hexpand (notebook->tabs_widget, TRUE);
- gtk_container_add (GTK_CONTAINER (notebook->header_widget), notebook->tabs_widget);
+ gtk_box_append (GTK_BOX (notebook->header_widget), notebook->tabs_widget);
notebook->stack_widget = gtk_stack_new ();
gtk_widget_set_hexpand (notebook->stack_widget, TRUE);
if (!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page))
{
g_object_ref (page->tab_label);
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (page->tab_label)), page->tab_label);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (page->tab_label)), page->tab_label);
gtk_widget_set_parent (page->tab_label, page->tab_widget);
g_object_unref (page->tab_label);
}
/* we hit this condition during dnd of a detached tab */
parent = gtk_widget_get_parent (page->tab_label);
if (GTK_IS_WINDOW (parent))
- gtk_container_remove (GTK_CONTAINER (parent), page->tab_label);
+ gtk_box_remove (GTK_BOX (parent), page->tab_label);
else
gtk_widget_unparent (page->tab_label);
}
GtkWidget *parent = gtk_widget_get_parent (page->menu_label);
if (parent)
- gtk_notebook_menu_label_unparent (parent, NULL);
+ gtk_notebook_menu_label_unparent (parent);
gtk_popover_set_child (GTK_POPOVER (notebook->menu), NULL);
gtk_widget_queue_resize (notebook->menu);
menu_item = gtk_button_new ();
gtk_button_set_has_frame (GTK_BUTTON (menu_item), FALSE);
gtk_button_set_child (GTK_BUTTON (menu_item), page->menu_label);
- gtk_container_add (GTK_CONTAINER (notebook->menu_box), menu_item);
+ gtk_box_append (GTK_BOX (notebook->menu_box), menu_item);
g_signal_connect (menu_item, "clicked",
G_CALLBACK (gtk_notebook_menu_switch_page), page);
if (!gtk_widget_get_visible (page->child))
GtkNotebookPage *page = list->data;
GtkWidget *menu_item = gtk_widget_get_parent (page->menu_label);
- gtk_container_remove (GTK_CONTAINER (menu_item), page->menu_label);
+ gtk_box_remove (GTK_BOX (menu_item), page->menu_label);
gtk_widget_unparent (menu_item);
gtk_notebook_menu_item_create (notebook, page);
}
static void
-gtk_notebook_menu_label_unparent (GtkWidget *widget,
- gpointer data)
+gtk_notebook_menu_label_unparent (GtkWidget *widget)
{
gtk_button_set_child (GTK_BUTTON (widget), NULL);
}
void
gtk_notebook_popup_disable (GtkNotebook *notebook)
{
+ GtkWidget *child;
+
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (!notebook->menu)
return;
- gtk_container_foreach (GTK_CONTAINER (notebook->menu_box),
- (GtkCallback) gtk_notebook_menu_label_unparent, NULL);
-
+ for (child = gtk_widget_get_first_child (notebook->menu_box);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ gtk_notebook_menu_label_unparent (child);
notebook->menu = NULL;
notebook->menu_box = NULL;
g_return_if_fail (!widget || gtk_widget_get_parent (widget) == NULL);
if (notebook->action_widget[pack_type])
- gtk_container_remove (GTK_CONTAINER (notebook->header_widget), notebook->action_widget[pack_type]);
+ gtk_box_remove (GTK_BOX (notebook->header_widget), notebook->action_widget[pack_type]);
notebook->action_widget[pack_type] = widget;
if (widget)
{
- gtk_container_add (GTK_CONTAINER (notebook->header_widget), widget);
+ gtk_box_append (GTK_BOX (notebook->header_widget), widget);
if (pack_type == GTK_PACK_START)
gtk_box_reorder_child_after (GTK_BOX (notebook->header_widget), widget, NULL);
else
*panes = g_list_prepend (*panes, widget);
get_child_panes (priv->end_child, panes);
}
- else if (GTK_IS_CONTAINER (widget))
+ else
{
- gtk_container_forall (GTK_CONTAINER (widget),
- (GtkCallback)get_child_panes, panes);
+ GtkWidget *child;
+
+ for (child = gtk_widget_get_first_child (widget);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ get_child_panes (child, panes);
}
}
button_data->image = gtk_image_new ();
button_data->label = gtk_label_new (NULL);
child = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (child), button_data->image);
- gtk_container_add (GTK_CONTAINER (child), button_data->label);
+ gtk_box_append (GTK_BOX (child), button_data->image);
+ gtk_box_append (GTK_BOX (child), button_data->label);
break;
case NORMAL_BUTTON:
default:
"spinning",
G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (header_name), label);
- gtk_container_add (GTK_CONTAINER (header_name), network_header_spinner);
- gtk_container_add (GTK_CONTAINER (header), header_name);
+ gtk_box_append (GTK_BOX (header_name), label);
+ gtk_box_append (GTK_BOX (header_name), network_header_spinner);
+ gtk_box_append (GTK_BOX (header), header_name);
}
else
{
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_margin_end (label, 12);
- gtk_container_add (GTK_CONTAINER (header), label);
+ gtk_box_append (GTK_BOX (header), label);
}
- gtk_container_add (GTK_CONTAINER (header), separator);
+ gtk_box_append (GTK_BOX (header), separator);
gtk_list_box_row_set_header (row, header);
/* Packing */
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
- gtk_container_add (GTK_CONTAINER (content_area), main_box);
+ gtk_box_append (GTK_BOX (content_area), main_box);
- gtk_container_add (GTK_CONTAINER (main_box), icon);
- gtk_container_add (GTK_CONTAINER (main_box), vbox);
+ gtk_box_append (GTK_BOX (main_box), icon);
+ gtk_box_append (GTK_BOX (main_box), vbox);
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
/* Right - 2. */
for (i = 0; i < length; i++)
gtk_entry_set_visibility (GTK_ENTRY (entry), ai_visible[i]);
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), box);
+ gtk_box_append (GTK_BOX (vbox), box);
- gtk_container_add (GTK_CONTAINER (box), label);
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), label);
+ gtk_box_append (GTK_BOX (box), entry);
g_signal_connect (entry, "changed",
G_CALLBACK (store_entry), &(priv->auth_info[i]));
gtk_widget_set_margin_top (chkbtn, 6);
gtk_widget_set_margin_bottom (chkbtn, 6);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkbtn), FALSE);
- gtk_container_add (GTK_CONTAINER (vbox), chkbtn);
+ gtk_box_append (GTK_BOX (vbox), chkbtn);
g_signal_connect (chkbtn, "toggled",
G_CALLBACK (store_auth_info_toggled),
&(priv->store_auth_info));
static void
alternative_set (GtkWidget *box,
- const gchar *value)
+ const gchar *value)
{
- gtk_container_foreach (GTK_CONTAINER (box),
- (GtkCallback) select_maybe,
- (gpointer) value);
+ GtkWidget *child;
+
+ for (child = gtk_widget_get_first_child (box);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ select_maybe (child, value);
}
static GSList *
button = gtk_radio_button_new_with_label (group, label);
gtk_widget_show (button);
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_object_set_data (G_OBJECT (button), "value", (gpointer)value);
g_signal_connect (button, "toggled",
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->combo), 0);
gtk_widget_set_sensitive (GTK_WIDGET (widget), FALSE);
gtk_widget_show (priv->combo);
- gtk_container_add (GTK_CONTAINER (widget), priv->combo);
+ gtk_box_append (GTK_BOX (widget), priv->combo);
}
else switch (source->type)
{
priv->check = gtk_check_button_new_with_mnemonic (source->display_text);
g_signal_connect (priv->check, "toggled", G_CALLBACK (check_toggled_cb), widget);
gtk_widget_show (priv->check);
- gtk_container_add (GTK_CONTAINER (widget), priv->check);
+ gtk_box_append (GTK_BOX (widget), priv->check);
break;
case GTK_PRINTER_OPTION_TYPE_PICKONE:
case GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD:
source->choices_display[i],
source->choices[i]);
gtk_widget_show (priv->combo);
- gtk_container_add (GTK_CONTAINER (widget), priv->combo);
+ gtk_box_append (GTK_BOX (widget), priv->combo);
g_signal_connect (priv->combo, "changed", G_CALLBACK (combo_changed_cb), widget);
text = g_strdup_printf ("%s:", source->display_text);
priv->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_set_valign (priv->box, GTK_ALIGN_BASELINE);
gtk_widget_show (priv->box);
- gtk_container_add (GTK_CONTAINER (widget), priv->box);
+ gtk_box_append (GTK_BOX (widget), priv->box);
for (i = 0; i < source->num_choices; i++)
{
group = alternative_append (priv->box,
gtk_entry_set_activates_default (GTK_ENTRY (priv->entry),
gtk_printer_option_get_activates_default (source));
gtk_widget_show (priv->entry);
- gtk_container_add (GTK_CONTAINER (widget), priv->entry);
+ gtk_box_append (GTK_BOX (widget), priv->entry);
g_signal_connect (priv->entry, "changed", G_CALLBACK (entry_changed_cb), widget);
text = g_strdup_printf ("%s:", source->display_text);
case GTK_PRINTER_OPTION_TYPE_FILESAVE:
priv->button = gtk_button_new ();
gtk_widget_show (priv->button);
- gtk_container_add (GTK_CONTAINER (widget), priv->button);
+ gtk_box_append (GTK_BOX (widget), priv->button);
g_signal_connect (priv->button, "clicked", G_CALLBACK (filesave_choose_cb), widget);
text = g_strdup_printf ("%s:", source->display_text);
case GTK_PRINTER_OPTION_TYPE_INFO:
priv->info_label = gtk_label_new (NULL);
gtk_label_set_selectable (GTK_LABEL (priv->info_label), TRUE);
- gtk_container_add (GTK_CONTAINER (widget), priv->info_label);
+ gtk_box_append (GTK_BOX (widget), priv->info_label);
text = g_strdup_printf ("%s:", source->display_text);
priv->label = gtk_label_new_with_mnemonic (text);
}
priv->image = gtk_image_new_from_icon_name ("dialog-warning");
- gtk_container_add (GTK_CONTAINER (widget), priv->image);
+ gtk_box_append (GTK_BOX (widget), priv->image);
}
/*
gtk_window_set_modal (GTK_WINDOW (plug), TRUE);
op_win32->embed_widget = plug;
- gtk_container_add (GTK_CONTAINER (plug), op->priv->custom_widget);
+ gtk_box_append (GTK_BOX (plug), op->priv->custom_widget);
gtk_widget_show (op->priv->custom_widget);
gtk_widget_show (plug);
button = gtk_dialog_get_widget_for_response (GTK_DIALOG (object), GTK_RESPONSE_APPLY);
g_object_ref (button);
parent = gtk_widget_get_ancestor (button, GTK_TYPE_HEADER_BAR);
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (button)), button);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (button)), button);
gtk_header_bar_pack_end (GTK_HEADER_BAR (parent), button);
g_object_unref (button);
}
g_free (bold_text);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
- gtk_container_add (GTK_CONTAINER (box), label_widget);
+ gtk_box_append (GTK_BOX (box), label_widget);
gtk_widget_set_margin_start (child, 12);
gtk_widget_set_halign (child, GTK_ALIGN_FILL);
gtk_widget_set_valign (child, GTK_ALIGN_FILL);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
return box;
}
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_set_valign (hbox, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), label);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), widget);
gtk_widget_show (hbox);
- gtk_container_add (GTK_CONTAINER (extension_point), hbox);
+ gtk_box_append (GTK_BOX (extension_point), hbox);
}
else
- gtk_container_add (GTK_CONTAINER (extension_point), widget);
+ gtk_box_append (GTK_BOX (extension_point), widget);
}
static gint
GtkWidget *table, *frame;
gboolean has_advanced, has_job;
guint nrows;
- GList *children;
+ GtkWidget *child;
if (dialog->current_printer == NULL)
{
* This keeps the file format radios from moving as the
* filename changes.
*/
- children = gtk_container_get_children (GTK_CONTAINER (dialog->extension_point));
- l = g_list_last (children);
- if (l && l != children)
- gtk_widget_set_halign (GTK_WIDGET (l->data), GTK_ALIGN_END);
- g_list_free (children);
+ child = gtk_widget_get_last_child (dialog->extension_point);
+ if (child && child != gtk_widget_get_first_child (dialog->extension_point))
+ gtk_widget_set_halign (child, GTK_ALIGN_END);
/* Put the rest of the groups in the advanced page */
groups = gtk_printer_option_set_get_groups (dialog->options);
{
has_advanced = TRUE;
frame = wrap_in_frame (group, table);
- gtk_container_add (GTK_CONTAINER (dialog->advanced_vbox), frame);
+ gtk_box_append (GTK_BOX (dialog->advanced_vbox), frame);
}
}
while ((child = gtk_widget_get_first_child (dialog->color_table)))
gtk_grid_remove (GTK_GRID (dialog->color_table), child);
while ((child = gtk_widget_get_first_child (dialog->advanced_vbox)))
- gtk_container_remove (GTK_CONTAINER (dialog->advanced_vbox), child);
+ gtk_box_remove (GTK_BOX (dialog->advanced_vbox), child);
while ((child = gtk_widget_get_first_child (dialog->extension_point)))
- gtk_container_remove (GTK_CONTAINER (dialog->extension_point), child);
+ gtk_box_remove (GTK_BOX (dialog->extension_point), child);
}
static void
* // Create a radio button with a GtkEntry widget
* radio1 = gtk_radio_button_new (NULL);
* entry = gtk_entry_new ();
- * gtk_container_add (GTK_CONTAINER (radio1), entry);
+ * gtk_box_append (GTK_BOX (radio1), entry);
*
*
* // Create a radio button with a label
* "I’m the second radio button.");
*
* // Pack them into a box, then show all the widgets
- * gtk_container_add (GTK_CONTAINER (box), radio1);
- * gtk_container_add (GTK_CONTAINER (box), radio2);
+ * gtk_box_append (GTK_BOX (box), radio1);
+ * gtk_box_append (GTK_BOX (box), radio2);
gtk_window_set_child (GTK_WINDOW (window),box);
* gtk_widget_show (window);
* return;
*
* // GtkButton is not a GtkScrollable, so GtkScrolledWindow will automatically
* // add a GtkViewport.
- * gtk_container_add (GTK_CONTAINER (scrolled_window),
+ * gtk_box_append (GTK_BOX (scrolled_window),
* child_widget);
*
* // Either of these will result in child_widget being unparented:
- * gtk_container_remove (GTK_CONTAINER (scrolled_window),
+ * gtk_box_remove (GTK_BOX (scrolled_window),
* child_widget);
* // or
- * gtk_container_remove (GTK_CONTAINER (scrolled_window),
+ * gtk_box_remove (GTK_BOX (scrolled_window),
* gtk_bin_get_child (GTK_BIN (scrolled_window)));
* ]|
*
gtk_shortcuts_group_set_accel_size_group (GtkShortcutsGroup *group,
GtkSizeGroup *size_group)
{
- GList *children, *l;
+ GtkWidget *child;
g_set_object (&group->accel_size_group, size_group);
- children = gtk_container_get_children (GTK_CONTAINER (group));
- for (l = children; l; l = l->next)
- gtk_shortcuts_group_apply_accel_size_group (group, GTK_WIDGET (l->data));
- g_list_free (children);
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (group));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ gtk_shortcuts_group_apply_accel_size_group (group, child);
}
static void
gtk_shortcuts_group_set_title_size_group (GtkShortcutsGroup *group,
GtkSizeGroup *size_group)
{
- GList *children, *l;
+ GtkWidget *child;
g_set_object (&group->title_size_group, size_group);
- children = gtk_container_get_children (GTK_CONTAINER (group));
- for (l = children; l; l = l->next)
- gtk_shortcuts_group_apply_title_size_group (group, GTK_WIDGET (l->data));
- g_list_free (children);
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (group));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ gtk_shortcuts_group_apply_title_size_group (group, child);
}
static guint
gtk_shortcuts_group_get_height (GtkShortcutsGroup *group)
{
- GList *children, *l;
+ GtkWidget *child;
guint height;
height = 1;
- children = gtk_container_get_children (GTK_CONTAINER (group));
- for (l = children; l; l = l->next)
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (group));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
{
- GtkWidget *child = l->data;
-
if (!gtk_widget_get_visible (child))
continue;
else if (GTK_IS_SHORTCUTS_SHORTCUT (child))
height += 1;
}
- g_list_free (children);
return height;
}
gtk_widget_is_ancestor (child, GTK_WIDGET (container)))
{
self->groups = g_list_remove (self->groups, child);
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (child)), child);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (child)), child);
}
else
GTK_CONTAINER_CLASS (gtk_shortcuts_section_parent_class)->remove (container, child);
if (column == NULL)
{
column = gtk_box_new (GTK_ORIENTATION_VERTICAL, 22);
- gtk_container_add (GTK_CONTAINER (page), column);
+ gtk_box_append (GTK_BOX (page), column);
}
- gtk_container_add (GTK_CONTAINER (column), GTK_WIDGET (group));
+ gtk_box_append (GTK_BOX (column), GTK_WIDGET (group));
self->groups = g_list_append (self->groups, group);
gtk_shortcuts_section_reflow_groups (self);
g_free (view);
}
- else if (GTK_IS_CONTAINER (child))
+ else
{
- gtk_container_foreach (GTK_CONTAINER (child), update_group_visibility, data);
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (child));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ update_group_visibility (child, self);
}
}
static void
gtk_shortcuts_section_filter_groups (GtkShortcutsSection *self)
{
+ GtkWidget *child;
+
self->has_filtered_group = FALSE;
- gtk_container_foreach (GTK_CONTAINER (self), update_group_visibility, self);
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (self));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ update_group_visibility (child, self);
gtk_widget_set_visible (GTK_WIDGET (self->show_all), self->has_filtered_group);
gtk_widget_set_visible (gtk_widget_get_parent (GTK_WIDGET (self->show_all)),
static void
gtk_shortcuts_section_reflow_groups (GtkShortcutsSection *self)
{
- GtkWidget *page, *column;
GList *pages, *p;
+ GtkWidget *page;
GList *groups, *g;
- GList *children;
guint n_rows;
guint n_columns;
guint n_pages;
page != NULL;
page = gtk_widget_get_next_sibling (page))
{
+ GtkWidget *column;
+
for (column = gtk_widget_get_first_child (page);
column != NULL;
column = gtk_widget_get_next_sibling (column))
{
- children = gtk_container_get_children (GTK_CONTAINER (column));
- groups = g_list_concat (groups, children);
+ GtkWidget *group;
+
+ for (group = gtk_widget_get_first_child (column);
+ group != NULL;
+ group = gtk_widget_get_next_sibling (group))
+ {
+ groups = g_list_prepend (groups, group);
+ }
}
}
+ groups = g_list_reverse (groups);
/* create new pages */
current_page = NULL;
current_page = page;
}
- gtk_container_add (GTK_CONTAINER (current_page), column_box);
+ gtk_box_append (GTK_BOX (current_page), column_box);
current_column = column_box;
n_columns += 1;
n_rows = 0;
NULL);
g_object_ref (group);
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (GTK_WIDGET (group))), GTK_WIDGET (group));
- gtk_container_add (GTK_CONTAINER (current_column), GTK_WIDGET (group));
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (GTK_WIDGET (group))), GTK_WIDGET (group));
+ gtk_box_append (GTK_BOX (current_column), GTK_WIDGET (group));
g_object_unref (group);
}
GtkWidget *column_box;
GtkSizeGroup *size_group;
GList *content;
+ GtkWidget *child;
guint n;
column_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 22);
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
g_object_set_data_full (G_OBJECT (column_box), "title-size-group", size_group, g_object_unref);
- gtk_container_add (GTK_CONTAINER (current_page), column_box);
+ gtk_box_append (GTK_BOX (current_page), column_box);
- content = gtk_container_get_children (GTK_CONTAINER (current_column));
+ content = NULL;
+ for (child = gtk_widget_get_last_child (current_column);
+ child != NULL;
+ child = gtk_widget_get_prev_sibling (child))
+ content = g_list_prepend (content, child);
+ content = g_list_reverse (content);
n = 0;
for (g = g_list_last (content); g; g = g->prev)
NULL);
g_object_ref (group);
- gtk_container_remove (GTK_CONTAINER (current_column), GTK_WIDGET (group));
- gtk_container_add (GTK_CONTAINER (column_box), GTK_WIDGET (group));
+ gtk_box_remove (GTK_BOX (current_column), GTK_WIDGET (group));
+ gtk_box_append (GTK_BOX (column_box), GTK_WIDGET (group));
g_object_unref (group);
}
gint offset)
{
GtkWidget *child;
- GList *children, *l;
child = gtk_stack_get_visible_child (self->stack);
- children = gtk_container_get_children (GTK_CONTAINER (self->stack));
- l = g_list_find (children, child);
if (offset == 1)
- l = l->next;
+ child = gtk_widget_get_next_sibling (child);
else if (offset == -1)
- l = l->prev;
+ child = gtk_widget_get_prev_sibling (child);
else
g_assert_not_reached ();
- if (l)
- gtk_stack_set_visible_child (self->stack, GTK_WIDGET (l->data));
+ if (child)
+ gtk_stack_set_visible_child (self->stack, child);
else
gtk_widget_error_bell (GTK_WIDGET (self));
- g_list_free (children);
-
return TRUE;
}
"visible", FALSE,
"valign", GTK_ALIGN_CENTER,
NULL);
- gtk_container_add (GTK_CONTAINER (self->box), GTK_WIDGET (self->image));
+ gtk_box_append (GTK_BOX (self->box), GTK_WIDGET (self->image));
self->accelerator = g_object_new (GTK_TYPE_SHORTCUT_LABEL,
"visible", TRUE,
"valign", GTK_ALIGN_CENTER,
NULL);
- gtk_container_add (GTK_CONTAINER (self->box), GTK_WIDGET (self->accelerator));
+ gtk_box_append (GTK_BOX (self->box), GTK_WIDGET (self->accelerator));
self->title_box = g_object_new (GTK_TYPE_BOX,
"visible", TRUE,
"hexpand", TRUE,
"orientation", GTK_ORIENTATION_VERTICAL,
NULL);
- gtk_container_add (GTK_CONTAINER (self->box), GTK_WIDGET (self->title_box));
+ gtk_box_append (GTK_BOX (self->box), GTK_WIDGET (self->title_box));
self->title = g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
"xalign", 0.0f,
NULL);
- gtk_container_add (GTK_CONTAINER (self->title_box), GTK_WIDGET (self->title));
+ gtk_box_append (GTK_BOX (self->title_box), GTK_WIDGET (self->title));
self->subtitle = g_object_new (GTK_TYPE_LABEL,
"visible", FALSE,
"xalign", 0.0f,
NULL);
gtk_widget_add_css_class (GTK_WIDGET (self->subtitle), GTK_STYLE_CLASS_DIM_LABEL);
- gtk_container_add (GTK_CONTAINER (self->title_box), GTK_WIDGET (self->subtitle));
+ gtk_box_append (GTK_BOX (self->title_box), GTK_WIDGET (self->subtitle));
}
g_hash_table_insert (priv->keywords, item, keywords);
if (shortcut_type == GTK_SHORTCUT_ACCELERATOR)
- gtk_container_add (GTK_CONTAINER (priv->search_shortcuts), item);
+ gtk_box_append (GTK_BOX (priv->search_shortcuts), item);
else
- gtk_container_add (GTK_CONTAINER (priv->search_gestures), item);
+ gtk_box_append (GTK_BOX (priv->search_gestures), item);
g_free (title);
g_free (accelerator);
g_free (str);
g_free (action_name);
}
- else if (GTK_IS_CONTAINER (child))
+ else
{
- gtk_container_foreach (GTK_CONTAINER (child), gtk_shortcuts_window_add_search_item, self);
+ GtkWidget *widget;
+
+ for (widget = gtk_widget_get_first_child (child);
+ widget != NULL;
+ widget = gtk_widget_get_next_sibling (widget))
+ gtk_shortcuts_window_add_search_item (widget, self);
}
}
gchar *name;
const gchar *visible_section;
GtkWidget *label;
+ GtkWidget *child;
- gtk_container_foreach (GTK_CONTAINER (section), gtk_shortcuts_window_add_search_item, self);
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (section));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ gtk_shortcuts_window_add_search_item (child, self);
g_object_get (section,
"section-name", &name,
if (GTK_IS_SHORTCUTS_SHORTCUT (widget))
gtk_shortcuts_shortcut_update_accel (GTK_SHORTCUTS_SHORTCUT (widget), priv->window);
- else if (GTK_IS_CONTAINER (widget))
- gtk_container_foreach (GTK_CONTAINER (widget), update_accels_cb, self);
+ else
+ {
+ GtkWidget *child;
+
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (widget));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child ))
+ update_accels_cb (child, self);
+ }
}
static void
g_object_bind_property (priv->search_bar, "search-mode-enabled",
search_button, "active",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
- gtk_container_add (GTK_CONTAINER (priv->main_box), GTK_WIDGET (priv->search_bar));
+ gtk_box_append (GTK_BOX (priv->main_box), GTK_WIDGET (priv->search_bar));
gtk_search_bar_set_key_capture_widget (GTK_SEARCH_BAR (priv->search_bar),
GTK_WIDGET (self));
"vhomogeneous", TRUE,
"transition-type", GTK_STACK_TRANSITION_TYPE_CROSSFADE,
NULL);
- gtk_container_add (GTK_CONTAINER (priv->main_box), GTK_WIDGET (priv->stack));
+ gtk_box_append (GTK_BOX (priv->main_box), GTK_WIDGET (priv->stack));
priv->title_stack = g_object_new (GTK_TYPE_STACK,
NULL);
"spacing", 6,
"orientation", GTK_ORIENTATION_VERTICAL,
NULL);
- gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_shortcuts));
+ gtk_box_append (GTK_BOX (box), GTK_WIDGET (priv->search_shortcuts));
priv->search_gestures = g_object_new (GTK_TYPE_BOX,
"halign", GTK_ALIGN_CENTER,
"spacing", 6,
"orientation", GTK_ORIENTATION_VERTICAL,
NULL);
- gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_gestures));
+ gtk_box_append (GTK_BOX (box), GTK_WIDGET (priv->search_gestures));
empty = g_object_new (GTK_TYPE_GRID,
"row-spacing", 12,
gtk_widget_add_css_class (item, "image-button");
gtk_actionable_set_action_name (GTK_ACTIONABLE (item), action_name);
gtk_widget_show (GTK_WIDGET (item));
- gtk_container_add (GTK_CONTAINER (toolbar), item);
+ gtk_box_append (GTK_BOX (toolbar), item);
}
static gboolean
toolbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_add_css_class (toolbar, "linked");
gtk_popover_set_child (GTK_POPOVER (priv->selection_bubble), box);
- gtk_container_add (GTK_CONTAINER (box), toolbar);
+ gtk_box_append (GTK_BOX (box), toolbar);
model = gtk_text_get_menu_model (self);
gtk_widget_add_css_class (item, "image-button");
gtk_actionable_set_action_name (GTK_ACTIONABLE (item), action_name);
- gtk_container_add (GTK_CONTAINER (toolbar), item);
+ gtk_box_append (GTK_BOX (toolbar), item);
}
static gboolean
toolbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_add_css_class (toolbar, "linked");
gtk_popover_set_child (GTK_POPOVER (priv->selection_bubble), box);
- gtk_container_add (GTK_CONTAINER (box), toolbar);
+ gtk_box_append (GTK_BOX (box), toolbar);
model = gtk_text_view_get_menu_model (text_view);
* g_signal_connect (toggle1, "toggled",
* G_CALLBACK (output_state),
* NULL);
- * gtk_container_add (GTK_CONTAINER (box), toggle1);
+ * gtk_box_append (GTK_BOX (box), toggle1);
*
* text = "Hi, I’m a toggle button.";
* toggle2 = gtk_toggle_button_new_with_label (text);
* g_signal_connect (toggle2, "toggled",
* G_CALLBACK (output_state),
* NULL);
- * gtk_container_add (GTK_CONTAINER (box), toggle2);
+ * gtk_box_append (GTK_BOX (box), toggle2);
*
* gtk_window_set_child (GTK_WINDOW (window), box);
* gtk_widget_show (window);
* gtk_tooltip_set_custom()
*/
window->custom_widget = NULL;
- gtk_container_remove (GTK_CONTAINER (window->box), custom);
+ gtk_box_remove (GTK_BOX (window->box), custom);
g_object_unref (custom);
}
{
window->custom_widget = g_object_ref (custom_widget);
- gtk_container_add (GTK_CONTAINER (window->box), custom_widget);
+ gtk_box_append (GTK_BOX (window->box), custom_widget);
gtk_widget_show (custom_widget);
gtk_widget_hide (window->image);
gtk_widget_hide (window->label);
GtkWidget *item;
gtk_tree_model_get_iter (popover->model, &iter, path);
item = gtk_tree_popover_create_item (popover, path, &iter, TRUE);
- gtk_container_add (GTK_CONTAINER (box), item);
- gtk_container_add (GTK_CONTAINER (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (box), item);
+ gtk_box_append (GTK_BOX (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
}
}
{
GtkWidget *box = gtk_widget_get_parent (item);
- gtk_container_remove (GTK_CONTAINER (box), item);
+ gtk_box_remove (GTK_BOX (box), item);
item = gtk_tree_popover_create_item (popover, path, iter, FALSE);
if (priv->xalign <= 0.5)
{
- gtk_container_add (GTK_CONTAINER (hbox), priv->frame);
- gtk_container_add (GTK_CONTAINER (hbox), priv->arrow);
+ gtk_box_append (GTK_BOX (hbox), priv->frame);
+ gtk_box_append (GTK_BOX (hbox), priv->arrow);
}
else
{
- gtk_container_add (GTK_CONTAINER (hbox), priv->arrow);
- gtk_container_add (GTK_CONTAINER (hbox), priv->frame);
+ gtk_box_append (GTK_BOX (hbox), priv->arrow);
+ gtk_box_append (GTK_BOX (hbox), priv->frame);
}
- gtk_container_add (GTK_CONTAINER (priv->frame), child);
+ gtk_box_append (GTK_BOX (priv->frame), child);
gtk_button_set_child (GTK_BUTTON (priv->button), hbox);
}
{
if (current_child != priv->child)
{
- gtk_container_remove (GTK_CONTAINER (frame), current_child);
- gtk_container_add (GTK_CONTAINER (frame), priv->child);
+ gtk_box_remove (GTK_BOX (frame), current_child);
+ gtk_box_append (GTK_BOX (frame), priv->child);
}
}
else
{
current_child = gtk_label_new (NULL);
gtk_widget_show (current_child);
- gtk_container_add (GTK_CONTAINER (frame), current_child);
+ gtk_box_append (GTK_BOX (frame), current_child);
}
g_return_if_fail (GTK_IS_LABEL (current_child));
if (priv->controller_observer)
gtk_list_list_model_clear (priv->controller_observer);
- if (priv->parent && GTK_IS_CONTAINER (priv->parent))
- gtk_container_remove (GTK_CONTAINER (priv->parent), widget);
- else if (priv->parent)
+ if (priv->parent)
gtk_widget_unparent (widget);
else if (_gtk_widget_get_visible (widget))
gtk_widget_hide (widget);
#include "gtkaccelgroupprivate.h"
#include "gtkactionable.h"
#include "gtkapplicationprivate.h"
+#include "gtkbox.h"
#include "gtkbuildable.h"
#include "gtkbuilderprivate.h"
#include "gtkcheckbutton.h"
check = gtk_check_button_new_with_label (_("Don’t show this message again"));
gtk_widget_set_margin_start (check, 10);
gtk_widget_show (check);
- gtk_container_add (GTK_CONTAINER (area), check);
+ gtk_box_append (GTK_BOX (area), check);
g_object_set_data (G_OBJECT (dialog), "check", check);
gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Cancel"), GTK_RESPONSE_NO);
gtk_dialog_add_button (GTK_DIALOG (dialog), _("_OK"), GTK_RESPONSE_YES);
gtk_widget_set_sensitive (menuitem, maximized && resizable);
g_signal_connect (G_OBJECT (menuitem), "clicked",
G_CALLBACK (restore_window_clicked), self);
- gtk_container_add (GTK_CONTAINER (box), menuitem);
+ gtk_box_append (GTK_BOX (box), menuitem);
menuitem = gtk_model_button_new ();
g_object_set (menuitem, "text", _("Move"), NULL);
gtk_widget_set_sensitive (menuitem, !maximized);
g_signal_connect (G_OBJECT (menuitem), "clicked",
G_CALLBACK (move_window_clicked), self);
- gtk_container_add (GTK_CONTAINER (box), menuitem);
+ gtk_box_append (GTK_BOX (box), menuitem);
menuitem = gtk_model_button_new ();
g_object_set (menuitem, "text", _("Resize"), NULL);
gtk_widget_set_sensitive (menuitem, resizable && !maximized);
g_signal_connect (G_OBJECT (menuitem), "clicked",
G_CALLBACK (resize_window_clicked), self);
- gtk_container_add (GTK_CONTAINER (box), menuitem);
+ gtk_box_append (GTK_BOX (box), menuitem);
menuitem = gtk_model_button_new ();
g_object_set (menuitem, "text", _("Minimize"), NULL);
g_signal_connect (G_OBJECT (menuitem), "clicked",
G_CALLBACK (minimize_window_clicked), self);
- gtk_container_add (GTK_CONTAINER (box), menuitem);
+ gtk_box_append (GTK_BOX (box), menuitem);
menuitem = gtk_model_button_new ();
g_object_set (menuitem, "text", _("Maximize"), NULL);
gtk_widget_set_sensitive (menuitem, resizable && !maximized);
g_signal_connect (G_OBJECT (menuitem), "clicked",
G_CALLBACK (maximize_window_clicked), self);
- gtk_container_add (GTK_CONTAINER (box), menuitem);
+ gtk_box_append (GTK_BOX (box), menuitem);
menuitem = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box), menuitem);
+ gtk_box_append (GTK_BOX (box), menuitem);
menuitem = gtk_model_button_new ();
g_object_set (menuitem, "text", _("Close"), NULL);
gtk_widget_set_sensitive (menuitem, deletable);
g_signal_connect (G_OBJECT (menuitem), "clicked",
G_CALLBACK (close_window_clicked), self);
- gtk_container_add (GTK_CONTAINER (box), menuitem);
+ gtk_box_append (GTK_BOX (box), menuitem);
g_signal_connect (self->fallback_menu, "closed",
G_CALLBACK (popup_menu_closed), self);
{
editor = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (editor), entry);
+ gtk_box_append (GTK_BOX (editor), entry);
label = gtk_label_new (g_variant_type_peek_string (type));
- gtk_container_add (GTK_CONTAINER (editor), label);
+ gtk_box_append (GTK_BOX (editor), label);
g_signal_connect (entry, "notify::text", G_CALLBACK (variant_editor_changed_cb), d);
}
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
activate = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (row), activate);
+ gtk_box_append (GTK_BOX (row), activate);
gtk_size_group_add_widget (r->priv->sg, activate);
r->priv->activate_button = gtk_button_new_with_label (_("Activate"));
g_signal_connect (r->priv->activate_button, "clicked", G_CALLBACK (activate_action), r);
gtk_widget_set_sensitive (r->priv->activate_button, r->priv->enabled);
- gtk_container_add (GTK_CONTAINER (activate), r->priv->activate_button);
+ gtk_box_append (GTK_BOX (activate), r->priv->activate_button);
r->priv->parameter_type = g_action_group_get_action_parameter_type (r->priv->group, r->priv->name);
if (r->priv->parameter_type)
{
r->priv->parameter_entry = variant_editor_new (r->priv->parameter_type, parameter_changed, r);
gtk_widget_set_sensitive (r->priv->parameter_entry, r->priv->enabled);
- gtk_container_add (GTK_CONTAINER (activate), r->priv->parameter_entry);
+ gtk_box_append (GTK_BOX (activate), r->priv->parameter_entry);
}
- gtk_container_add (GTK_CONTAINER (r), row);
+ gtk_box_append (GTK_BOX (r), row);
if (state)
{
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
label = gtk_label_new (_("Set State"));
gtk_size_group_add_widget (r->priv->sg, label);
- gtk_container_add (GTK_CONTAINER (row), label);
+ gtk_box_append (GTK_BOX (row), label);
r->priv->state_entry = variant_editor_new (r->priv->state_type, state_changed, r);
variant_editor_set_value (r->priv->state_entry, state);
- gtk_container_add (GTK_CONTAINER (row), r->priv->state_entry);
- gtk_container_add (GTK_CONTAINER (r), row);
+ gtk_box_append (GTK_BOX (row), r->priv->state_entry);
+ gtk_box_append (GTK_BOX (r), row);
}
g_signal_connect (r->priv->group, "action-enabled-changed",
gtk_widget_add_css_class (label, "cell");
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_size_group_add_widget (sl->priv->name, label);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
label = gtk_label_new (enabled ? "+" : "-");
gtk_widget_add_css_class (label, "cell");
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_widget_set_halign (label, GTK_ALIGN_CENTER);
gtk_size_group_add_widget (sl->priv->enabled, label);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
g_object_set_data (G_OBJECT (row), "enabled", label);
gtk_widget_add_css_class (label, "cell");
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_size_group_add_widget (sl->priv->parameter, label);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
label = gtk_label_new (state_string);
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_widget_add_css_class (label, "cell");
gtk_size_group_add_widget (sl->priv->state, label);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
g_object_set_data (G_OBJECT (row), "state", label);
editor = gtk_inspector_action_editor_new (group, name, sl->priv->activate);
gtk_widget_add_css_class (editor, "cell");
- gtk_container_add (GTK_CONTAINER (box), editor);
+ gtk_box_append (GTK_BOX (box), editor);
g_object_set_data (G_OBJECT (row), "editor", editor);
gtk_list_box_insert (GTK_LIST_BOX (sl->priv->list), row, -1);
gtk_widget_set_halign (sl->priv->listbox, GTK_ALIGN_CENTER);
g_signal_connect (sl->priv->listbox, "row-activated", G_CALLBACK (row_activated), sl);
gtk_list_box_set_selection_mode (GTK_LIST_BOX (sl->priv->listbox), GTK_SELECTION_NONE);
- gtk_container_add (GTK_CONTAINER (box), sl->priv->listbox);
+ gtk_box_append (GTK_BOX (box), sl->priv->listbox);
- gtk_container_add (GTK_CONTAINER (sl), sw);
+ gtk_box_append (GTK_BOX (sl), sw);
}
static void
gtk_widget_set_margin_bottom (box, 10);
label = gtk_label_new (G_OBJECT_TYPE_NAME (controller));
g_object_set (label, "xalign", 0.0, NULL);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
gtk_size_group_add_widget (sl->priv->sizegroup, label);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (combo), GTK_PHASE_BUBBLE, C_("event phase", "Bubble"));
gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (combo), GTK_PHASE_TARGET, C_("event phase", "Target"));
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), gtk_event_controller_get_propagation_phase (controller));
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
gtk_widget_set_halign (label, GTK_ALIGN_END);
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_widget_set_hexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
check = gtk_image_new_from_icon_name ("object-select-symbolic");
gtk_widget_set_halign (check, GTK_ALIGN_END);
gtk_widget_set_valign (check, GTK_ALIGN_BASELINE);
gtk_widget_set_opacity (check, value ? 1.0 : 0.0);
- gtk_container_add (GTK_CONTAINER (box), check);
+ gtk_box_append (GTK_BOX (box), check);
row = gtk_list_box_row_new ();
gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_widget_set_hexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
label = gtk_label_new (value);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_widget_set_halign (label, GTK_ALIGN_END);
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_label_set_xalign (GTK_LABEL (label), 1.0);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
row = gtk_list_box_row_new ();
gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);
GList *list, *l;
while ((child = gtk_widget_get_first_child (sl->priv->mnemonic_label)))
- gtk_widget_unparent (child);
+ gtk_box_remove (GTK_BOX (sl->priv->mnemonic_label), child);
list = gtk_widget_list_mnemonic_labels (GTK_WIDGET (sl->priv->object));
for (l = list; l; l = l->next)
button = gtk_button_new_with_label (tmp);
g_free (tmp);
gtk_widget_show (button);
- gtk_container_add (GTK_CONTAINER (sl->priv->mnemonic_label), button);
+ gtk_box_append (GTK_BOX (sl->priv->mnemonic_label), button);
g_object_set_data (G_OBJECT (button), "mnemonic-label", l->data);
g_signal_connect (button, "clicked", G_CALLBACK (show_mnemonic_label), sl);
}
column = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_size_group_add_widget (wt->priv->type_size_group, column);
- gtk_container_add (GTK_CONTAINER (box), column);
+ gtk_box_append (GTK_BOX (box), column);
/* expander */
depth = gtk_tree_list_row_get_depth (row_item);
{
child = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_size_request (child, 16 * depth, 0);
- gtk_container_add (GTK_CONTAINER (column), child);
+ gtk_box_append (GTK_BOX (column), child);
}
if (gtk_tree_list_row_is_expandable (row_item))
{
title = g_object_new (GTK_TYPE_TOGGLE_BUTTON, "css-name", "title", NULL);
gtk_button_set_has_frame (GTK_BUTTON (title), FALSE);
g_object_bind_property (row_item, "expanded", title, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (child), title);
+ gtk_box_append (GTK_BOX (child), title);
arrow = gtk_builtin_icon_new ("expander");
gtk_button_set_child (GTK_BUTTON (title), arrow);
{
child = gtk_image_new (); /* empty whatever */
}
- gtk_container_add (GTK_CONTAINER (column), child);
+ gtk_box_append (GTK_BOX (column), child);
/* 1st column: type name */
child = gtk_label_new (G_OBJECT_TYPE_NAME (item));
gtk_label_set_width_chars (GTK_LABEL (child), 30);
gtk_label_set_xalign (GTK_LABEL (child), 0.0);
- gtk_container_add (GTK_CONTAINER (column), child);
+ gtk_box_append (GTK_BOX (column), child);
/* 2nd column: name */
child = gtk_label_new (gtk_inspector_get_object_name (item));
gtk_label_set_width_chars (GTK_LABEL (child), 15);
gtk_label_set_xalign (GTK_LABEL (child), 0.0);
gtk_size_group_add_widget (wt->priv->name_size_group, child);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
/* 3rd column: label */
child = gtk_label_new (NULL);
gtk_label_set_width_chars (GTK_LABEL (child), 15);
gtk_label_set_xalign (GTK_LABEL (child), 0.0);
gtk_size_group_add_widget (wt->priv->label_size_group, child);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
g_object_unref (item);
g_signal_connect (button, "clicked", G_CALLBACK (item_properties), user_data);
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
- gtk_container_add (GTK_CONTAINER (row), label);
- gtk_container_add (GTK_CONTAINER (row), button);
+ gtk_box_append (GTK_BOX (row), label);
+ gtk_box_append (GTK_BOX (row), button);
return row;
}
b = gtk_check_button_new_with_label (fclass->values[j].value_nick);
g_object_set_data (G_OBJECT (b), "index", GINT_TO_POINTER (j));
gtk_widget_show (b);
- gtk_container_add (GTK_CONTAINER (box), b);
+ gtk_box_append (GTK_BOX (box), b);
connect_controller (G_OBJECT (b), "toggled",
object, spec, G_CALLBACK (flags_modified));
}
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (object_properties),
editor);
- gtk_container_add (GTK_CONTAINER (prop_edit), label);
- gtk_container_add (GTK_CONTAINER (prop_edit), button);
+ gtk_box_append (GTK_BOX (prop_edit), label);
+ gtk_box_append (GTK_BOX (prop_edit), button);
gtk_widget_show (label);
gtk_widget_show (button);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
label = gtk_label_new (_("Attribute:"));
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
button = gtk_button_new_with_label (_("Model"));
g_object_set_data (G_OBJECT (button), "model", model);
g_signal_connect (button, "clicked", G_CALLBACK (model_properties), editor);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Column:")));
+ gtk_box_append (GTK_BOX (box), gtk_label_new (_("Column:")));
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_text_new ();
attribute_mapping_changed (GTK_COMBO_BOX (combo), editor);
g_signal_connect (combo, "changed",
G_CALLBACK (attribute_mapping_changed), editor);
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
return box;
}
{
text = g_strdup_printf (_("Action from: %p (%s)"),
owner, g_type_name_from_instance ((GTypeInstance *)owner));
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new (text));
+ gtk_box_append (GTK_BOX (box), gtk_label_new (text));
g_free (text);
button = gtk_button_new_with_label (_("Properties"));
g_object_set_data (G_OBJECT (button), "owner", owner);
g_signal_connect (button, "clicked",
G_CALLBACK (show_action_owner), editor);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
}
return box;
GParamSpec *spec)
{
if (GTK_IS_CELL_RENDERER (editor->priv->object))
- gtk_container_add (GTK_CONTAINER (editor),
+ gtk_box_append (GTK_BOX (editor),
attribute_editor (editor->priv->object, spec, editor));
}
{
if (GTK_IS_ACTIONABLE (editor->priv->object) &&
g_strcmp0 (editor->priv->name, "action-name") == 0)
- gtk_container_add (GTK_CONTAINER (editor),
+ gtk_box_append (GTK_BOX (editor),
action_editor (editor->priv->object, editor));
}
}
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (row), gtk_label_new (_("Setting:")));
+ gtk_box_append (GTK_BOX (row), gtk_label_new (_("Setting:")));
label = gtk_label_new (direction);
if (tip)
gtk_widget_set_tooltip_text (label, tip);
- gtk_container_add (GTK_CONTAINER (row), label);
+ gtk_box_append (GTK_BOX (row), label);
str = g_strdup_printf ("%s %s",
g_settings_schema_get_id (binding->key.schema),
binding->key.name);
label = gtk_label_new (str);
- gtk_container_add (GTK_CONTAINER (row), label);
+ gtk_box_append (GTK_BOX (row), label);
g_free (str);
- gtk_container_add (GTK_CONTAINER (editor), row);
+ gtk_box_append (GTK_BOX (editor), row);
}
static void
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
button = gtk_button_new_with_label (_("Reset"));
- gtk_container_add (GTK_CONTAINER (row), button);
+ gtk_box_append (GTK_BOX (row), button);
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect_swapped (button, "clicked", G_CALLBACK (reset_setting), editor);
source = _("Unknown");
break;
}
- gtk_container_add (GTK_CONTAINER (row), gtk_label_new (_("Source:")));
- gtk_container_add (GTK_CONTAINER (row), gtk_label_new (source));
+ gtk_box_append (GTK_BOX (row), gtk_label_new (_("Source:")));
+ gtk_box_append (GTK_BOX (row), gtk_label_new (source));
- gtk_container_add (GTK_CONTAINER (editor), row);
+ gtk_box_append (GTK_BOX (editor), row);
}
static void
if (label)
{
gtk_widget_add_css_class (label, GTK_STYLE_CLASS_DIM_LABEL);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
}
/* By reaching this, we already know the property is readable.
{
label = gtk_label_new ("");
gtk_widget_add_css_class (label, GTK_STYLE_CLASS_DIM_LABEL);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
readonly_changed (editor->priv->object, spec, label);
g_object_connect_property (editor->priv->object, spec,
if (editor->priv->size_group)
gtk_size_group_add_widget (editor->priv->size_group, box);
- gtk_container_add (GTK_CONTAINER (editor), box);
+ gtk_box_append (GTK_BOX (editor), box);
return;
}
editor->priv->editor = property_editor (editor->priv->object, spec, editor);
- gtk_container_add (GTK_CONTAINER (box), editor->priv->editor);
+ gtk_box_append (GTK_BOX (box), editor->priv->editor);
if (editor->priv->size_group)
gtk_size_group_add_widget (editor->priv->size_group, box);
- gtk_container_add (GTK_CONTAINER (editor), box);
+ gtk_box_append (GTK_BOX (editor), box);
add_attribute_info (editor, spec);
add_actionable_info (editor);
gtk_widget_set_sensitive (label, writable);
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_size_group_add_widget (pl->priv->names, label);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
label = gtk_label_new (type ? type : "");
gtk_widget_add_css_class (label, "cell");
gtk_widget_set_sensitive (label, writable);
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_size_group_add_widget (pl->priv->types, label);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
label = gtk_label_new (g_type_name (prop->owner_type));
gtk_widget_add_css_class (label, "cell");
gtk_widget_set_sensitive (label, writable);
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_size_group_add_widget (pl->priv->origins, label);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
widget = gtk_inspector_prop_editor_new (pl->priv->object, prop->name, pl->priv->values);
gtk_widget_add_css_class (widget, "cell");
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
g_signal_connect (widget, "show-object", G_CALLBACK (show_object), pl);
g_free (value);
pl->priv->object = object;
while ((w = gtk_widget_get_first_child (pl->priv->list2)))
- gtk_container_remove (GTK_CONTAINER (pl->priv->list2), w);
+ gtk_list_box_remove (GTK_LIST_BOX (pl->priv->list2), w);
for (i = 0; i < num_properties; i++)
{
{
child = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_size_request (child, 16 * depth, 0);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
}
if (gtk_tree_list_row_is_expandable (row_item))
{
title = g_object_new (GTK_TYPE_TOGGLE_BUTTON, "css-name", "title", NULL);
gtk_button_set_has_frame (GTK_BUTTON (title), FALSE);
g_object_bind_property (row_item, "expanded", title, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (child), title);
+ gtk_box_append (GTK_BOX (child), title);
g_object_set_data_full (G_OBJECT (row), "make-sure-its-not-unreffed", g_object_ref (row_item), g_object_unref);
arrow = gtk_builtin_icon_new ("expander");
{
child = gtk_image_new (); /* empty whatever */
}
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
/* icon */
child = gtk_image_new_from_paintable (paintable);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
/* name */
name = node_name (node);
child = gtk_label_new (name);
g_free (name);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
g_object_unref (paintable);
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
- gtk_container_add (GTK_CONTAINER (widget), hbox);
+ gtk_box_append (GTK_BOX (widget), hbox);
for (i = 0; i < g_list_model_get_n_items (priv->recordings); i++)
{
label = gtk_label_new (str);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
g_free (str);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
button = gtk_toggle_button_new ();
gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
gtk_button_set_icon_name (GTK_BUTTON (button), "view-more-symbolic");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
label = gtk_label_new (gtk_inspector_render_recording_get_profiler_info (GTK_INSPECTOR_RENDER_RECORDING (recording)));
gtk_widget_hide (label);
- gtk_container_add (GTK_CONTAINER (widget), label);
+ gtk_box_append (GTK_BOX (widget), label);
g_object_bind_property (button, "active", label, "visible", 0);
}
else
label = gtk_label_new (s);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
g_free (s);
- gtk_container_add (GTK_CONTAINER (row), label);
+ gtk_box_append (GTK_BOX (row), label);
gtk_size_group_add_widget (sl->trigger, label);
s = gtk_shortcut_action_to_string (action);
label = gtk_label_new (s);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
g_free (s);
- gtk_container_add (GTK_CONTAINER (row), label);
+ gtk_box_append (GTK_BOX (row), label);
gtk_size_group_add_widget (sl->action, label);
return row;
parent = gtk_widget_get_parent (GTK_WIDGET (row));
if (parent)
- gtk_container_remove (GTK_CONTAINER (parent), GTK_WIDGET (row));
+ gtk_box_remove (GTK_BOX (parent), GTK_WIDGET (row));
}
static void
GtkWidget *child;
while ((child = gtk_widget_get_first_child (GTK_WIDGET (sl))))
- gtk_container_remove (GTK_CONTAINER (sl), child);
+ gtk_box_remove (GTK_BOX (sl), child);
}
static void
GtkWidget *listbox;
frame = gtk_frame_new (NULL);
- gtk_container_add (GTK_CONTAINER (sl), frame);
+ gtk_box_append (GTK_BOX (sl), frame);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_add_css_class (box, GTK_STYLE_CLASS_VIEW);
gtk_frame_set_child (GTK_FRAME (frame), box);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (box), box2);
+ gtk_box_append (GTK_BOX (box), box2);
label = gtk_label_new (_("Mode"));
gtk_widget_set_margin_start (label, 10);
gtk_widget_set_margin_bottom (label, 10);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (box2), label);
+ gtk_box_append (GTK_BOX (box2), label);
combo = gtk_combo_box_text_new ();
gtk_widget_set_margin_start (combo, 10);
g_object_bind_property (group, "mode",
combo, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (box2), combo);
+ gtk_box_append (GTK_BOX (box2), combo);
listbox = gtk_list_box_new ();
- gtk_container_add (GTK_CONTAINER (box), listbox);
+ gtk_box_append (GTK_BOX (box), listbox);
gtk_list_box_set_selection_mode (GTK_LIST_BOX (listbox), GTK_SELECTION_NONE);
widgets = gtk_size_group_get_widgets (group);
GtkWidget *row;
row = gtk_widget_get_parent (GTK_WIDGET (button));
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (row)), row);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (row)), row);
emit_changed (editor);
}
entry = gtk_entry_new ();
gtk_editable_set_text (GTK_EDITABLE (entry), str);
gtk_widget_show (entry);
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), entry);
g_object_set_data (G_OBJECT (box), "entry", entry);
g_signal_connect_swapped (entry, "notify::text", G_CALLBACK (emit_changed), editor);
button = gtk_button_new_from_icon_name ("user-trash-symbolic");
gtk_widget_add_css_class (button, "image-button");
gtk_widget_show (button);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_signal_connect (button, "clicked", G_CALLBACK (remove_string), editor);
- gtk_container_add (GTK_CONTAINER (editor->box), box);
+ gtk_box_append (GTK_BOX (editor->box), box);
gtk_widget_grab_focus (entry);
gtk_widget_show (editor->button);
g_signal_connect (editor->button, "clicked", G_CALLBACK (add_cb), editor);
- gtk_container_add (GTK_CONTAINER (editor), editor->box);
- gtk_container_add (GTK_CONTAINER (editor), editor->button);
+ gtk_box_append (GTK_BOX (editor), editor->box);
+ gtk_box_append (GTK_BOX (editor), editor->button);
}
static void
editor->blocked = TRUE;
while ((child = gtk_widget_get_first_child (GTK_WIDGET (editor->box))))
- gtk_container_remove (GTK_CONTAINER (editor->box), child);
+ gtk_box_remove (GTK_BOX (editor->box), child);
if (strv)
{
g_object_ref (widget);
if (gtk_widget_get_parent (widget) != NULL)
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (widget)), widget);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (widget)), widget);
gtk_window_set_child (GTK_WINDOW (window), widget);
g_object_unref (widget);
}
}
label = gtk_label_new (text);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
adj = gtk_adjustment_new (gtk_gears_get_axis (gears, axis), 0.0, 360.0, 1.0, 12.0, 0.0);
g_object_set_data (G_OBJECT (adj), "axis", GINT_TO_POINTER (axis));
gears);
slider = gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj);
gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
- gtk_container_add (GTK_CONTAINER (box), slider);
+ gtk_box_append (GTK_BOX (box), slider);
gtk_widget_set_vexpand (slider, TRUE);
return box;
static void
moar_gears (GtkButton *button, gpointer data)
{
- GtkContainer *container = GTK_CONTAINER (data);
GtkWidget *gears;
gears = gtk_gears_new ();
gtk_widget_set_size_request (gears, 100, 100);
- gtk_container_add (container, gears);
+ gtk_box_append (GTK_BOX (data), gears);
}
static void
less_gears (GtkButton *button, gpointer data)
{
- GtkContainer *container = GTK_CONTAINER (data);
GtkWidget *gears;
- gears = gtk_widget_get_last_child (GTK_WIDGET (container));
+ gears = gtk_widget_get_last_child (GTK_WIDGET (data));
if (gears)
- gtk_container_remove (container, gears);
+ gtk_box_remove (GTK_BOX (data), gears);
}
static void
gtk_frame_set_child (GTK_FRAME (frame), hbox);
label = gtk_label_new ("This is a transparent overlay widget!!!!\nAmazing, eh?");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE);
gtk_box_set_spacing (GTK_BOX (box), 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
gtk_box_set_spacing (GTK_BOX (box), 6);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
gears = gtk_gears_new ();
gtk_widget_set_hexpand (gears, TRUE);
gtk_widget_set_vexpand (gears, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), gears);
+ gtk_box_append (GTK_BOX (hbox), gears);
for (i = 0; i < GTK_GEARS_N_AXIS; i++)
- gtk_container_add (GTK_CONTAINER (hbox), create_axis_slider (GTK_GEARS (gears), i));
+ gtk_box_append (GTK_BOX (hbox), create_axis_slider (GTK_GEARS (gears), i));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
gtk_box_set_spacing (GTK_BOX (hbox), 6);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
fps_label = gtk_label_new ("");
gtk_widget_set_hexpand (fps_label, TRUE);
gtk_widget_set_halign (fps_label, GTK_ALIGN_START);
- gtk_container_add (GTK_CONTAINER (hbox), fps_label);
+ gtk_box_append (GTK_BOX (hbox), fps_label);
gtk_gears_set_fps_label (GTK_GEARS (gears), GTK_LABEL (fps_label));
gtk_popover_set_child (GTK_POPOVER (popover), label);
gtk_menu_button_set_popover (GTK_MENU_BUTTON (button), popover);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
check = gtk_check_button_new_with_label ("Overlay");
- gtk_container_add (GTK_CONTAINER (hbox), check);
+ gtk_box_append (GTK_BOX (hbox), check);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), FALSE);
g_signal_connect (check, "toggled",
G_CALLBACK (toggle_overlay), revealer);
check = gtk_check_button_new_with_label ("Animate spinner");
- gtk_container_add (GTK_CONTAINER (hbox), check);
+ gtk_box_append (GTK_BOX (hbox), check);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
spinner = gtk_spinner_new ();
- gtk_container_add (GTK_CONTAINER (hbox), spinner);
+ gtk_box_append (GTK_BOX (hbox), spinner);
gtk_spinner_start (GTK_SPINNER (spinner));
g_signal_connect (check, "toggled",
G_CALLBACK (toggle_spin), spinner);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_NEVER);
- gtk_container_add (GTK_CONTAINER (box), scrolled);
+ gtk_box_append (GTK_BOX (box), scrolled);
extra_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
gtk_box_set_spacing (GTK_BOX (extra_hbox), 6);
bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_spacing (GTK_BOX (bbox), 6);
- gtk_container_add (GTK_CONTAINER (box), bbox);
+ gtk_box_append (GTK_BOX (box), bbox);
button = gtk_button_new_with_label ("Moar gears!");
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (moar_gears), extra_hbox);
button = gtk_button_new_with_label ("Less gears!");
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (less_gears), extra_hbox);
button = gtk_button_new_with_label ("Quit");
gtk_widget_set_hexpand (button, TRUE);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
gtk_widget_show (window);
da = gtk_drawing_area_new ();
gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), on_draw, NULL, NULL);
gtk_widget_set_vexpand (da, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), da);
+ gtk_box_append (GTK_BOX (vbox), da);
label = gtk_label_new ("Event processing time (ms):");
gtk_widget_set_halign (label, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
adjustment = gtk_adjustment_new (20, 0, 200, 1, 10, 0);
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
- gtk_container_add (GTK_CONTAINER (vbox), scale);
+ gtk_box_append (GTK_BOX (vbox), scale);
controller = gtk_event_controller_motion_new ();
g_signal_connect (controller, "motion",
GTK_POLICY_AUTOMATIC);
gtk_widget_set_hexpand (sw, TRUE);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
content = get_content ();
g_signal_connect (combo, "changed", G_CALLBACK (mode_changed), sw);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
sb2 = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adj);
- gtk_container_add (GTK_CONTAINER (box), sb2);
+ gtk_box_append (GTK_BOX (box), sb2);
gtk_widget_show (window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
gtk_widget_show (hbox);
label = gtk_label_new ("Font:");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
gtk_widget_show (label);
font = gtk_font_button_new_with_font (data->font);
- gtk_container_add (GTK_CONTAINER (hbox), font);
+ gtk_box_append (GTK_BOX (hbox), font);
gtk_widget_show (font);
data->font_button = font;
gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (sw), TRUE);
gtk_widget_set_vexpand (sw, TRUE);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
contents = gtk_text_view_new ();
gtk_widget_grab_focus (contents);
/* Create statusbar */
statusbar = gtk_statusbar_new ();
- gtk_container_add (GTK_CONTAINER (box), statusbar);
+ gtk_box_append (GTK_BOX (box), statusbar);
/* Show text widget info in the statusbar */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
result = GTK_WIDGET (gtk_builder_get_object (builder, "box1"));
g_object_ref (result);
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (result)),
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (result)),
result);
g_object_unref (builder);
gdk_texture_get_width (texture),
gdk_texture_get_height (texture));
- gtk_container_add (GTK_CONTAINER (box), nodeview);
- gtk_container_add (GTK_CONTAINER (box), image);
+ gtk_box_append (GTK_BOX (box), nodeview);
+ gtk_box_append (GTK_BOX (box), image);
gtk_window_set_child (GTK_WINDOW (window), box);
gsk_renderer_unrealize (renderer);
GTK_POLICY_NEVER,
GTK_POLICY_EXTERNAL);
gtk_widget_set_hexpand (sw, TRUE);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
tv = gtk_text_view_new ();
fill_text_view (tv, "Left");
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), tv);
GTK_POLICY_NEVER,
GTK_POLICY_EXTERNAL);
gtk_widget_set_hexpand (sw, TRUE);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
tv = gtk_text_view_new ();
fill_text_view (tv, "Middle");
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), tv);
GTK_POLICY_NEVER,
GTK_POLICY_EXTERNAL);
gtk_widget_set_hexpand (sw, TRUE);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
tv = gtk_text_view_new ();
fill_text_view (tv, "Right");
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), tv);
sb = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adj);
- gtk_container_add (GTK_CONTAINER (box), sb);
+ gtk_box_append (GTK_BOX (box), sb);
gtk_widget_show (win);
gtk_widget_set_vexpand (sw, TRUE);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_window_set_child (GTK_WINDOW (window), box);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
store = gtk_list_store_new (3, G_TYPE_INT, G_TYPE_UINT, G_TYPE_UINT);
tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
}
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), entry);
return window;
}
g_signal_connect (G_OBJECT (toggle),
"toggled", G_CALLBACK (on_set_small_size_requests),
NULL);
- gtk_container_add (GTK_CONTAINER (box), toggle);
+ gtk_box_append (GTK_BOX (box), toggle);
toggle =
gtk_toggle_button_new_with_label ("Set large size requests");
g_signal_connect (G_OBJECT (toggle),
"toggled", G_CALLBACK (on_set_large_size_requests),
NULL);
- gtk_container_add (GTK_CONTAINER (box), toggle);
+ gtk_box_append (GTK_BOX (box), toggle);
gtk_widget_show (window);
inner_box = gtk_overlay_new ();
gtk_widget_add_css_class (inner_box, "blue-bg");
- gtk_container_add (GTK_CONTAINER (outer_box), inner_box);
+ gtk_box_append (GTK_BOX (outer_box), inner_box);
test_widget = gtk_overlay_new ();
gtk_widget_add_css_class (test_widget, "red-bg");
- gtk_container_add (GTK_CONTAINER (inner_box), test_widget);
+ gtk_box_append (GTK_BOX (inner_box), test_widget);
label = gtk_label_new (text);
- gtk_container_add (GTK_CONTAINER (test_widget), label);
+ gtk_box_append (GTK_BOX (test_widget), label);
g_assert (TEST_WIDGET (outer_box) == test_widget);
GtkWidget *child =
create_margined(margins[i]);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
}
gtk_widget_show (test_window);
gtk_window_set_child (GTK_WINDOW (window), box);
label = gtk_label_new ("Both labels expand");
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
label = gtk_label_new ("Some wrapping text with width-chars = 15 and max-width-chars = 35");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
gtk_window_present (GTK_WINDOW (window));
}
button = gtk_app_chooser_button_new ("image/jpeg");
gtk_widget_set_vexpand (button, TRUE);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_signal_connect (button, "changed",
G_CALLBACK (combo_changed_cb), NULL);
w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (w), "<b>Selected app info</b>");
gtk_widget_set_vexpand (w, TRUE);
- gtk_container_add (GTK_CONTAINER (box), w);
+ gtk_box_append (GTK_BOX (box), w);
w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_set_vexpand (w, TRUE);
- gtk_container_add (GTK_CONTAINER (box), w);
+ gtk_box_append (GTK_BOX (box), w);
sel_image = gtk_image_new ();
gtk_widget_set_hexpand (sel_image, TRUE);
- gtk_container_add (GTK_CONTAINER (w), sel_image);
+ gtk_box_append (GTK_BOX (w), sel_image);
sel_name = gtk_label_new (NULL);
gtk_widget_set_hexpand (sel_name, TRUE);
- gtk_container_add (GTK_CONTAINER (w), sel_name);
+ gtk_box_append (GTK_BOX (w), sel_name);
gtk_app_chooser_button_set_heading (GTK_APP_CHOOSER_BUTTON (button), "Choose one, <i>not</i> two");
gtk_app_chooser_button_append_separator (GTK_APP_CHOOSER_BUTTON (button));
page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
check = gtk_check_button_new_with_label ("Complete");
- gtk_container_add (GTK_CONTAINER (page), gtk_label_new (text));
- gtk_container_add (GTK_CONTAINER (page), check);
+ gtk_box_append (GTK_BOX (page), gtk_label_new (text));
+ gtk_box_append (GTK_BOX (page), check);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), complete);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
g_signal_connect (G_OBJECT (check), "toggled",
G_CALLBACK (visible_cb), next);
- gtk_container_add (GTK_CONTAINER (page), check);
+ gtk_box_append (GTK_BOX (page), check);
add_completion_test_page (assistant, "Even More Content", TRUE, TRUE);
page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
button = gtk_radio_button_new_with_label (NULL, "branch A");
- gtk_container_add (GTK_CONTAINER (page), button);
+ gtk_box_append (GTK_BOX (page), button);
g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (select_branch), GINT_TO_POINTER ('A'));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
button = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"branch B");
- gtk_container_add (GTK_CONTAINER (page), button);
+ gtk_box_append (GTK_BOX (page), button);
g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (select_branch), GINT_TO_POINTER ('B'));
gtk_assistant_append_page (GTK_ASSISTANT (assistant), page);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), page, TRUE);
page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (page),
+ gtk_box_append (GTK_BOX (page),
get_test_page ("Page 2"));
gtk_assistant_append_page (GTK_ASSISTANT (assistant), page);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), page, "Page 2");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (buttons[i].func), NULL);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
}
gtk_widget_show (window);
for (j = 0; j < 2; j++)
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
const char *aligns_names[] = { "FILL", "BASELINE" };
GtkAlign aligns[] = { GTK_ALIGN_FILL, GTK_ALIGN_BASELINE};
label = gtk_label_new (aligns_names[j]);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
for (i = 0; i < 3; i++) {
label = gtk_label_new ("│XYyj,Ö...");
gtk_widget_set_valign (label, aligns[j]);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
}
for (i = 0; i < 3; i++) {
gtk_widget_set_valign (entry, aligns[j]);
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (hbox), entry);
}
spin = gtk_spin_button_new (NULL, 0, 1);
gtk_orientable_set_orientation (GTK_ORIENTABLE (spin), GTK_ORIENTATION_VERTICAL);
gtk_widget_set_valign (spin, aligns[j]);
- gtk_container_add (GTK_CONTAINER (hbox), spin);
+ gtk_box_append (GTK_BOX (hbox), spin);
spin = gtk_spin_button_new (NULL, 0, 1);
gtk_widget_set_valign (spin, aligns[j]);
- gtk_container_add (GTK_CONTAINER (hbox), spin);
+ gtk_box_append (GTK_BOX (hbox), spin);
}
grid_hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[0]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[1]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[2]);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
- gtk_container_add (GTK_CONTAINER (hbox), combo);
+ gtk_box_append (GTK_BOX (hbox), combo);
for (j = 0; j < 2; j++)
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (baseline_position_changed), hbox);
label = gtk_label_new ("Baseline:");
else
label = gtk_label_new ("Normal:");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
for (i = 0; i < 3; i++)
{
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
}
for (i = 0; i < 3; i++)
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
- gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("face-sad"));
+ gtk_box_append (GTK_BOX (box), gtk_label_new ("│Xyj,Ö"));
+ gtk_box_append (GTK_BOX (box), gtk_image_new_from_icon_name ("face-sad"));
gtk_button_set_child (GTK_BUTTON (button), box);
set_font_size (button, i);
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
}
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 34);
if (j == 0)
gtk_widget_set_valign (image, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), image);
+ gtk_box_append (GTK_BOX (hbox), image);
button = gtk_toggle_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_toggle_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_check_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_radio_button_new_with_label (NULL, "│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
}
vbox, gtk_label_new ("grid"));
grid_hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Align me:");
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
grid = gtk_grid_new ();
gtk_widget_set_valign (grid, GTK_ALIGN_BASELINE);
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
- gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("face-sad"));
+ gtk_box_append (GTK_BOX (box), gtk_label_new ("│Xyj,Ö"));
+ gtk_box_append (GTK_BOX (box), gtk_image_new_from_icon_name ("face-sad"));
gtk_button_set_child (GTK_BUTTON (button), box);
set_font_size (button, i);
}
- gtk_container_add (GTK_CONTAINER (hbox), grid);
+ gtk_box_append (GTK_BOX (hbox), grid);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
adjustment = gtk_adjustment_new (0.0, -1.0, 5.0, 1.0, 1.0, 0.0);
spin = gtk_spin_button_new (adjustment, 1.0, 0);
g_signal_connect (spin, "value-changed", (GCallback)baseline_row_value_changed, grid);
- gtk_container_add (GTK_CONTAINER (hbox), spin);
+ gtk_box_append (GTK_BOX (hbox), spin);
toggle = gtk_toggle_button_new_with_label ("Homogeneous");
g_signal_connect (toggle, "toggled", (GCallback)homogeneous_changed, grid);
- gtk_container_add (GTK_CONTAINER (hbox), toggle);
+ gtk_box_append (GTK_BOX (hbox), toggle);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[0]);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (baseline_position_changed), grid_hbox);
- gtk_container_add (GTK_CONTAINER (hbox), combo);
+ gtk_box_append (GTK_BOX (hbox), combo);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("button box"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
adjustment = gtk_adjustment_new (34.0, 1.0, 64.0, 1.0, 1.0, 0.0);
spin = gtk_spin_button_new (adjustment, 1.0, 0);
- gtk_container_add (GTK_CONTAINER (hbox), spin);
+ gtk_box_append (GTK_BOX (hbox), spin);
adjustment = gtk_adjustment_new (16.0, 1.0, 64.0, 1.0, 1.0, 0.0);
spin2 = gtk_spin_button_new (adjustment, 1.0, 0);
- gtk_container_add (GTK_CONTAINER (hbox), spin2);
+ gtk_box_append (GTK_BOX (hbox), spin2);
for (j = 0; j < 3; j++)
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
gtk_box_set_baseline_position (GTK_BOX (hbox), j);
label = gtk_label_new (baseline_pos_str[j]);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
gtk_widget_set_vexpand (label, TRUE);
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 34);
- gtk_container_add (GTK_CONTAINER (hbox), image);
+ gtk_box_append (GTK_BOX (hbox), image);
g_signal_connect (spin, "value-changed", (GCallback)image_size_value_changed, image);
if (i != 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
}
for (i = 0; i < 3; i++)
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
+ gtk_box_append (GTK_BOX (box), gtk_label_new ("│Xyj,Ö"));
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
- gtk_container_add (GTK_CONTAINER (box), image);
+ gtk_box_append (GTK_BOX (box), image);
gtk_button_set_child (GTK_BUTTON (button), box);
if (i == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
}
}
gtk_label_set_attributes (GTK_LABEL (value_label), attrs);
pango_attr_list_unref (attrs);
}
- gtk_container_add (GTK_CONTAINER (blur_box), value_label);
+ gtk_box_append (GTK_BOX (blur_box), value_label);
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 10, 0.05);
g_signal_connect (scale, "value-changed", G_CALLBACK (value_changed_cb), blur_box);
g_signal_connect (scale, "value-changed", G_CALLBACK (value_changed_cb2), value_label);
- gtk_container_add (GTK_CONTAINER (blur_box), scale);
+ gtk_box_append (GTK_BOX (blur_box), scale);
gtk_window_set_child (GTK_WINDOW (window), blur_box);
gtk_widget_show (window);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "one");
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "two");
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "three");
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "four");
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "five");
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
/* Bottom */
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "b1");
- gtk_container_add (GTK_CONTAINER (bottom), w);
+ gtk_box_append (GTK_BOX (bottom), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "b2");
- gtk_container_add (GTK_CONTAINER (bottom), w);
+ gtk_box_append (GTK_BOX (bottom), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "b3");
- gtk_container_add (GTK_CONTAINER (bottom), w);
+ gtk_box_append (GTK_BOX (bottom), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "b4");
- gtk_container_add (GTK_CONTAINER (bottom), w);
+ gtk_box_append (GTK_BOX (bottom), w);
- gtk_container_add (GTK_CONTAINER (box), top);
- gtk_container_add (GTK_CONTAINER (box), bottom);
+ gtk_box_append (GTK_BOX (box), top);
+ gtk_box_append (GTK_BOX (box), bottom);
gtk_window_set_child (GTK_WINDOW (window), box);
g_signal_connect (window, "destroy", G_CALLBACK (quit_cb), &done);
gtk_widget_show (window);
"row-spacing", 10,
"column-spacing", 10,
NULL);
- gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), grid);
+ gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), grid);
label = gtk_label_new ("Label:");
gtk_widget_set_halign (label, GTK_ALIGN_END);
gtk_window_set_child (GTK_WINDOW (window), vbox);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), test_widget ("1"));
- gtk_container_add (GTK_CONTAINER (box), test_widget ("2"));
- gtk_container_add (GTK_CONTAINER (box), test_widget ("3"));
- gtk_container_add (GTK_CONTAINER (box), test_widget ("4"));
- gtk_container_add (GTK_CONTAINER (box), test_widget ("5"));
- gtk_container_add (GTK_CONTAINER (box), test_widget ("6"));
+ gtk_box_append (GTK_BOX (box), test_widget ("1"));
+ gtk_box_append (GTK_BOX (box), test_widget ("2"));
+ gtk_box_append (GTK_BOX (box), test_widget ("3"));
+ gtk_box_append (GTK_BOX (box), test_widget ("4"));
+ gtk_box_append (GTK_BOX (box), test_widget ("5"));
+ gtk_box_append (GTK_BOX (box), test_widget ("6"));
- gtk_container_add (GTK_CONTAINER (vbox), box);
+ gtk_box_append (GTK_BOX (vbox), box);
check = gtk_check_button_new_with_label ("Homogeneous");
g_object_bind_property (box, "homogeneous",
gtk_widget_set_margin_top (check, 10);
gtk_widget_set_margin_bottom (check, 10);
gtk_widget_set_halign (check, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), check);
+ gtk_box_append (GTK_BOX (vbox), check);
b = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_widget_set_margin_start (b, 10);
gtk_widget_set_halign (b, GTK_ALIGN_CENTER);
label = gtk_label_new ("Spacing:");
gtk_widget_set_halign (label, GTK_ALIGN_END);
- gtk_container_add (GTK_CONTAINER (b), label);
+ gtk_box_append (GTK_BOX (b), label);
spin = gtk_spin_button_new_with_range (0, 10, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spin), TRUE);
gtk_widget_set_halign (spin, GTK_ALIGN_START);
g_signal_connect (spin, "value-changed",
G_CALLBACK (spacing_changed), box);
- gtk_container_add (GTK_CONTAINER (b), spin);
- gtk_container_add (GTK_CONTAINER (vbox), b);
+ gtk_box_append (GTK_BOX (b), spin);
+ gtk_box_append (GTK_BOX (vbox), b);
gtk_widget_show (window);
gtk_window_set_child (GTK_WINDOW (window), box);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
button = g_object_new (GTK_TYPE_BUTTON,
"label", "document-save",
NULL);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_object_get (button,
"label", &text,
text = g_strdup_printf ("label: \"%s\" icon-name: \"%s\" use-underline: %s\n", text, icon_name, use_underline ? "TRUE" : "FALSE");
label = gtk_label_new (text);
g_free (text);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
button = gtk_button_new_with_label ("_Save");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_object_get (button,
"label", &text,
text = g_strdup_printf ("label: \"%s\" icon-name: \"%s\" use-underline: %s\n", text, icon_name, use_underline ? "TRUE" : "FALSE");
label = gtk_label_new (text);
g_free (text);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
button = gtk_button_new_with_mnemonic ("_Save");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_object_get (button,
"label", &text,
text = g_strdup_printf ("label: \"%s\" icon-name: \"%s\" use-underline: %s\n", text, icon_name, use_underline ? "TRUE" : "FALSE");
label = gtk_label_new (text);
g_free (text);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
button = gtk_button_new_from_icon_name ("help-about");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_object_get (button,
"label", &text,
text = g_strdup_printf ("label: \"%s\" icon-name: \"%s\" use-underline: %s\n", text, icon_name, use_underline ? "TRUE" : "FALSE");
label = gtk_label_new (text);
g_free (text);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
button = gtk_button_new ();
gtk_button_set_icon_name (GTK_BUTTON (button), "help-about");
gtk_button_set_use_underline (GTK_BUTTON (button), TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_object_get (button,
"label", &text,
"use-underline", &use_underline,
text = g_strdup_printf ("label: \"%s\" icon-name: \"%s\" use-underline: %s\n", text, icon_name, use_underline ? "TRUE" : "FALSE");
label = gtk_label_new (text);
g_free (text);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
gtk_widget_show (window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, DEF_PAD_SMALL);
frame = create_frame ("<b>Options</b>", vbox, GTK_ALIGN_FILL, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (rpane), frame);
+ gtk_box_append (GTK_BOX (rpane), frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, DEF_PAD_SMALL);
gtk_widget_set_halign (hbox, GTK_ALIGN_START);
gtk_widget_set_valign (hbox, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
/* Build the Right frame with the flags in */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (rpane), vbox);
+ gtk_box_append (GTK_BOX (rpane), vbox);
for (i = 0; i < G_N_ELEMENTS (flags); i++)
{
GtkWidget *toggle = gtk_check_button_new_with_mnemonic (flags[i].label);
gboolean value;
- gtk_container_add (GTK_CONTAINER (vbox), toggle);
+ gtk_box_append (GTK_BOX (vbox), toggle);
g_object_get (G_OBJECT (calendar), flags[i].prop_name, &value, NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), value);
frame = create_frame ("<b>Signal Events</b>", vbox, GTK_ALIGN_FILL, GTK_ALIGN_CENTER);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Signal:");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
calendar_data.last_sig = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (hbox), calendar_data.last_sig);
+ gtk_box_append (GTK_BOX (hbox), calendar_data.last_sig);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Previous signal:");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
calendar_data.prev_sig = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (hbox), calendar_data.prev_sig);
+ gtk_box_append (GTK_BOX (hbox), calendar_data.prev_sig);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Second previous signal:");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
calendar_data.prev2_sig = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (hbox), calendar_data.prev2_sig);
+ gtk_box_append (GTK_BOX (hbox), calendar_data.prev2_sig);
/*
* Glue everything together
button = gtk_button_new_with_label ("Close");
g_signal_connect (button, "clicked", G_CALLBACK (quit_cb), &done);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, DEF_PAD_SMALL);
- gtk_container_add (GTK_CONTAINER (vbox), hpaned);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
- gtk_container_add (GTK_CONTAINER (vbox), frame);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
- gtk_container_add (GTK_CONTAINER (vbox), bbox);
+ gtk_box_append (GTK_BOX (vbox), hpaned);
+ gtk_box_append (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (vbox), bbox);
gtk_window_set_child (GTK_WINDOW (window), vbox);
/* Now add some controls */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
- gtk_container_add (GTK_CONTAINER (hbox), frame);
+ gtk_box_append (GTK_BOX (hbox), frame);
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (orientation_changed), iconview);
widget = gtk_check_button_new_with_label ("Align 2nd Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (align_cell_2_toggled), iconview);
widget = gtk_check_button_new_with_label ("Align 3rd Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (align_cell_3_toggled), iconview);
widget = gtk_check_button_new_with_label ("Expand 1st Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (expand_cell_1_toggled), iconview);
widget = gtk_check_button_new_with_label ("Expand 2nd Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (expand_cell_2_toggled), iconview);
widget = gtk_check_button_new_with_label ("Expand 3rd Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (expand_cell_3_toggled), iconview);
/* Now add some controls */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
- gtk_container_add (GTK_CONTAINER (hbox), frame);
+ gtk_box_append (GTK_BOX (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), frame);
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (orientation_changed), iconview);
widget = gtk_check_button_new_with_label ("Focus Sibling");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (focus_sibling_toggled), iconview);
"prepended space distributed to the background area.");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_width_chars (GTK_LABEL (label), 40);
- gtk_container_add (GTK_CONTAINER (main_vbox), label);
+ gtk_box_append (GTK_BOX (main_vbox), label);
iconview = focus_iconview (TRUE, NULL, NULL);
/* Now add some controls */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
- gtk_container_add (GTK_CONTAINER (hbox), frame);
+ gtk_box_append (GTK_BOX (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), frame);
- gtk_container_add (GTK_CONTAINER (main_vbox), hbox);
+ gtk_box_append (GTK_BOX (main_vbox), hbox);
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
- gtk_container_add (GTK_CONTAINER (vbox), widget);
+ gtk_box_append (GTK_BOX (vbox), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (orientation_changed), iconview);
label = gtk_label_new ("Cell spacing");
gtk_widget_set_hexpand (label, TRUE);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
- gtk_container_add (GTK_CONTAINER (hbox), label);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (vbox), hbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (cell_spacing_changed), iconview);
label = gtk_label_new ("Row spacing");
gtk_widget_set_hexpand (label, TRUE);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
- gtk_container_add (GTK_CONTAINER (hbox), label);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (vbox), hbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (row_spacing_changed), iconview);
gtk_widget_set_hexpand (label, TRUE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), gtk_icon_view_get_item_padding (GTK_ICON_VIEW (iconview)));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
- gtk_container_add (GTK_CONTAINER (hbox), label);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (vbox), hbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (item_padding_changed), iconview);
/* LTR */
label = gtk_label_new ("Left to right");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
tree = create_tree (FALSE);
gtk_widget_set_vexpand (tree, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), tree);
+ gtk_box_append (GTK_BOX (vbox), tree);
/* RTL */
label = gtk_label_new ("Right to left");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
tree = create_tree (TRUE);
gtk_widget_set_vexpand (tree, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), tree);
+ gtk_box_append (GTK_BOX (vbox), tree);
gtk_widget_show (window);
GtkWidget *box;
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new (format_name));
+ gtk_box_append (GTK_BOX (box), gtk_label_new (format_name));
gdk_content_formats_unref (formats);
gtk_list_box_insert (GTK_LIST_BOX (list), box, -1);
if (provider)
g_object_set_data_full (G_OBJECT (button), "provider", provider, g_object_unref);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
}
static GtkWidget *
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new (info));
+ gtk_box_append (GTK_BOX (box), gtk_label_new (info));
add_provider_button (box,
NULL,
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new (name));
+ gtk_box_append (GTK_BOX (hbox), vbox);
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new (name));
switcher = gtk_stack_switcher_new ();
- gtk_container_add (GTK_CONTAINER (vbox), switcher);
+ gtk_box_append (GTK_BOX (vbox), switcher);
stack = get_contents_widget (clipboard);
- gtk_container_add (GTK_CONTAINER (vbox), stack);
+ gtk_box_append (GTK_BOX (vbox), stack);
gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER (switcher), GTK_STACK (stack));
- gtk_container_add (GTK_CONTAINER (hbox), get_button_list (clipboard, "Set Locally:"));
+ gtk_box_append (GTK_BOX (hbox), get_button_list (clipboard, "Set Locally:"));
if (clipboard != alt_clipboard)
- gtk_container_add (GTK_CONTAINER (hbox), get_button_list (alt_clipboard, "Set Remotely:"));
+ gtk_box_append (GTK_BOX (hbox), get_button_list (alt_clipboard, "Set Remotely:"));
return hbox;
}
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_set_homogeneous (GTK_BOX (box), TRUE);
- gtk_container_add (GTK_CONTAINER (box),
+ gtk_box_append (GTK_BOX (box),
get_clipboard_widget (gdk_display_get_clipboard (display),
gdk_display_get_clipboard (alt_display),
"Clipboard"));
- gtk_container_add (GTK_CONTAINER (box),
+ gtk_box_append (GTK_BOX (box),
get_clipboard_widget (gdk_display_get_primary_clipboard (display),
gdk_display_get_primary_clipboard (alt_display),
"Primary Clipboard"));
/* GtkCellView */
tmp = gtk_frame_new ("GtkCellView");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
renderer,
TRUE);
g_object_set (renderer, "text", "la la la", NULL);
- gtk_container_add (GTK_CONTAINER (boom), cellview);
+ gtk_box_append (GTK_BOX (boom), cellview);
/* GtkComboBox list */
tmp = gtk_frame_new ("GtkComboBox (list)");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
model = create_list_blaat ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (boom), combobox);
+ gtk_box_append (GTK_BOX (boom), combobox);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
/* GtkComboBox dynamic list */
tmp = gtk_frame_new ("GtkComboBox (dynamic list)");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
G_CALLBACK (populate_list_blaat), combobox);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (boom), combobox);
+ gtk_box_append (GTK_BOX (boom), combobox);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
/* GtkComboBox custom entry */
tmp = gtk_frame_new ("GtkComboBox (custom)");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
model = create_list_blaat ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (boom), combobox);
+ gtk_box_append (GTK_BOX (boom), combobox);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
/* GtkComboBox tree */
tmp = gtk_frame_new ("GtkComboBox (tree)");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
model = create_tree_blaat ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (boom), combobox);
+ gtk_box_append (GTK_BOX (boom), combobox);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
/* GtkComboBox (grid mode) */
tmp = gtk_frame_new ("GtkComboBox (grid mode)");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
/* GtkComboBoxEntry */
tmp = gtk_frame_new ("GtkComboBox with entry");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
comboboxtext = gtk_combo_box_text_new_with_entry ();
setup_combo_entry (GTK_COMBO_BOX_TEXT (comboboxtext));
- gtk_container_add (GTK_CONTAINER (boom), comboboxtext);
+ gtk_box_append (GTK_BOX (boom), comboboxtext);
/* Phylogenetic tree */
tmp = gtk_frame_new ("What are you ?");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
model = create_phylogenetic_tree ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (boom), combobox);
+ gtk_box_append (GTK_BOX (boom), combobox);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
/* Capitals */
tmp = gtk_frame_new ("Where are you ?");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
model = create_capital_tree ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (boom), combobox);
+ gtk_box_append (GTK_BOX (boom), combobox);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
/* Aligned Food */
tmp = gtk_frame_new ("Hungry ?");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
model = create_food_list ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (boom), combobox);
+ gtk_box_append (GTK_BOX (boom), combobox);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (combobox));
/* Ellipsizing growing combos */
tmp = gtk_frame_new ("Unconstrained Menu");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (tmp), boom);
model = create_list_long ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
- gtk_container_add (GTK_CONTAINER (boom), combobox);
+ gtk_box_append (GTK_BOX (boom), combobox);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_combo_box_set_popup_fixed_width (GTK_COMBO_BOX (combobox), FALSE);
tmp = gtk_frame_new ("Looong");
- gtk_container_add (GTK_CONTAINER (mainbox), tmp);
+ gtk_box_append (GTK_BOX (mainbox), tmp);
combobox = gtk_combo_box_text_new ();
for (i = 0; i < 200; i++)
{
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
- gtk_container_add (GTK_CONTAINER (content_area), hbox);
+ gtk_box_append (GTK_BOX (content_area), hbox);
combo_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (hbox), combo_vbox);
+ gtk_box_append (GTK_BOX (hbox), combo_vbox);
combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
cell_renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell_renderer,
"text", 0, NULL);
gtk_widget_set_margin_start (combo, 12);
- gtk_container_add (GTK_CONTAINER (combo_vbox), combo);
+ gtk_box_append (GTK_BOX (combo_vbox), combo);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_hexpand (scrolled_window, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), scrolled_window);
+ gtk_box_append (GTK_BOX (hbox), scrolled_window);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled_window), text_view);
button_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (hbox), button_vbox);
+ gtk_box_append (GTK_BOX (hbox), button_vbox);
gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 300);
button = gtk_button_new_with_label ("Insert");
- gtk_container_add (GTK_CONTAINER (button_vbox), button);
+ gtk_box_append (GTK_BOX (button_vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (on_insert), NULL);
button = gtk_button_new_with_label ("Delete");
- gtk_container_add (GTK_CONTAINER (button_vbox), button);
+ gtk_box_append (GTK_BOX (button_vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (on_delete), NULL);
button = gtk_button_new_with_label ("Reorder");
- gtk_container_add (GTK_CONTAINER (button_vbox), button);
+ gtk_box_append (GTK_BOX (button_vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (on_reorder), NULL);
button = gtk_button_new_with_label ("Animate");
- gtk_container_add (GTK_CONTAINER (button_vbox), button);
+ gtk_box_append (GTK_BOX (button_vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (on_animate), NULL);
gtk_widget_show (dialog);
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), label);
+ gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), label);
}
static void
box = gtk_flow_box_new ();
gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (box), GTK_SELECTION_NONE);
gtk_widget_set_hexpand (box, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), box);
+ gtk_box_append (GTK_BOX (vbox), box);
button = gtk_button_new_with_label ("Message dialog");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_message_dialog1), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Message with icon");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_message_dialog1a), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Confirmation dialog");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_message_dialog2), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Builtin");
button = gtk_button_new_with_label ("Builtin");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_color_chooser), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Generic Builtin");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_color_chooser_generic), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Simple");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_dialog), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("With Header");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_dialog_with_header), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("With Buttons");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_dialog_with_buttons), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Header & Buttons");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_dialog_with_header_buttons), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Header & Buttons & Builder");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_dialog_with_header_buttons2), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Template");
button = gtk_button_new_with_label ("Template");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_dialog_from_template), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Template With Header");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_dialog_from_template_with_header), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_button_new_with_label ("Flexible Template");
g_signal_connect_swapped (button, "clicked", G_CALLBACK (show_dialog_flex_template), window);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_flow_box_insert (GTK_FLOW_BOX (box), button, -1);
button = gtk_check_button_new_with_label ("Dialogs have headers");
g_object_bind_property (gtk_settings_get_default (), "gtk-dialogs-use-header",
button, "active",
G_BINDING_BIDIRECTIONAL|G_BINDING_SYNC_CREATE);
gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (button));
gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
while (TRUE)
g_main_context_iteration (NULL, TRUE);
gtk_popover_set_child (GTK_POPOVER (popover), box);
button = gtk_button_new_with_label ("Copy");
g_signal_connect (button, "clicked", G_CALLBACK (do_copy), NULL);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_label ("Move");
g_signal_connect (button, "clicked", G_CALLBACK (do_copy), NULL);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_label ("Cancel");
g_signal_connect (button, "clicked", G_CALLBACK (do_cancel), NULL);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
}
gtk_popover_popup (GTK_POPOVER (popover));
}
gtk_window_set_child (GTK_WINDOW (window), box);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), box2);
+ gtk_box_append (GTK_BOX (box), box2);
canvas = canvas_new ();
- gtk_container_add (GTK_CONTAINER (box2), canvas);
+ gtk_box_append (GTK_BOX (box2), canvas);
x = y = 40;
for (i = 0; i < 4; i++)
GtkWidget *item;
item = canvas_item_new (i, x, y, 0);
- gtk_container_add (GTK_CONTAINER (canvas), item);
+ gtk_box_append (GTK_BOX (canvas), item);
apply_transform (item);
x += 150;
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_NEVER);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_add_css_class (box3, "linked");
"rgba", &rgba,
"selectable", FALSE,
NULL);
- gtk_container_add (GTK_CONTAINER (box3), swatch);
+ gtk_box_append (GTK_BOX (box3), swatch);
}
gtk_widget_show (window);
gtk_widget_set_vexpand (overlay, TRUE);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), label);
- gtk_container_add (GTK_CONTAINER (vbox), combo);
- gtk_container_add (GTK_CONTAINER (vbox), scale);
- gtk_container_add (GTK_CONTAINER (vbox), overlay);
+ gtk_box_append (GTK_BOX (vbox), combo);
+ gtk_box_append (GTK_BOX (vbox), scale);
+ gtk_box_append (GTK_BOX (vbox), overlay);
g_object_set_data (G_OBJECT (label), "combo", combo);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "Completion demo, try writing <b>total</b> or <b>gnome</b> for example.");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
/* Create our first entry */
entry = gtk_entry_new ();
gtk_entry_set_completion (GTK_ENTRY (entry), completion);
g_object_unref (completion);
- gtk_container_add (GTK_CONTAINER (vbox), entry);
+ gtk_box_append (GTK_BOX (vbox), entry);
/* Create a tree model and use it as the completion model */
completion_model = create_simple_completion_model ();
gtk_entry_set_completion (GTK_ENTRY (entry), completion);
g_object_unref (completion);
- gtk_container_add (GTK_CONTAINER (vbox), entry);
+ gtk_box_append (GTK_BOX (vbox), entry);
/* Create a tree model and use it as the completion model */
completion_model = create_completion_model ();
gtk_entry_set_completion (GTK_ENTRY (entry), completion);
g_object_unref (completion);
- gtk_container_add (GTK_CONTAINER (vbox), entry);
+ gtk_box_append (GTK_BOX (vbox), entry);
/* Create a tree model and use it as the completion model */
completion_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
g_timeout_add (1000, (GSourceFunc) animation_timer, completion);
/* Fourth entry */
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("Model-less entry completion"));
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new ("Model-less entry completion"));
entry = gtk_entry_new ();
gtk_entry_set_completion (GTK_ENTRY (entry), completion);
g_object_unref (completion);
- gtk_container_add (GTK_CONTAINER (vbox), entry);
+ gtk_box_append (GTK_BOX (vbox), entry);
gtk_widget_show (window);
button1 = gtk_radio_button_new_with_label (NULL, "Blank");
gtk_widget_set_valign (button1, GTK_ALIGN_START);
g_signal_connect (button1, "toggled", G_CALLBACK (set_blank), entry);
- gtk_container_add (GTK_CONTAINER (box), button1);
+ gtk_box_append (GTK_BOX (box), button1);
button2 = gtk_radio_button_new_with_label (NULL, "Icon Name");
gtk_widget_set_valign (button2, GTK_ALIGN_START);
gtk_radio_button_join_group (GTK_RADIO_BUTTON (button2), GTK_RADIO_BUTTON (button1));
g_signal_connect (button2, "toggled", G_CALLBACK (set_icon_name), entry);
- gtk_container_add (GTK_CONTAINER (box), button2);
+ gtk_box_append (GTK_BOX (box), button2);
button3 = gtk_radio_button_new_with_label (NULL, "GIcon");
gtk_widget_set_valign (button3, GTK_ALIGN_START);
gtk_radio_button_join_group (GTK_RADIO_BUTTON (button3), GTK_RADIO_BUTTON (button1));
g_signal_connect (button3, "toggled", G_CALLBACK (set_gicon), entry);
- gtk_container_add (GTK_CONTAINER (box), button3);
+ gtk_box_append (GTK_BOX (box), button3);
button4 = gtk_radio_button_new_with_label (NULL, "Texture");
gtk_widget_set_valign (button4, GTK_ALIGN_START);
gtk_radio_button_join_group (GTK_RADIO_BUTTON (button4), GTK_RADIO_BUTTON (button1));
g_signal_connect (button4, "toggled", G_CALLBACK (set_texture), entry);
- gtk_container_add (GTK_CONTAINER (box), button4);
+ gtk_box_append (GTK_BOX (box), button4);
label = gtk_label_new ("Emoji:");
gtk_grid_attach (GTK_GRID (grid), label, 0, 6, 1, 1);
gtk_widget_set_cursor_from_name (box, "text");
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
- gtk_container_add (GTK_CONTAINER (box), entry);
+ gtk_box_append (GTK_BOX (box), entry);
image = gtk_image_new_from_icon_name ("edit-find-symbolic");
gtk_widget_set_cursor_from_name (image, "default");
gtk_widget_set_margin_start (image, 6);
gesture = gtk_gesture_click_new ();
g_signal_connect (gesture, "pressed", G_CALLBACK (icon_pressed_cb), NULL);
gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (gesture));
- gtk_container_add (GTK_CONTAINER (box), image);
+ gtk_box_append (GTK_BOX (box), image);
image = gtk_image_new_from_icon_name ("document-save-symbolic");
gtk_widget_set_margin_start (image, 6);
gtk_widget_set_margin_end (image, 6);
gtk_widget_set_margin_top (image, 6);
gtk_widget_set_margin_bottom (image, 6);
- gtk_container_add (GTK_CONTAINER (box), image);
+ gtk_box_append (GTK_BOX (box), image);
gtk_grid_attach (GTK_GRID (grid), box, 1, 7, 1, 1);
GtkCssProvider *provider;
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (box1),
+ gtk_box_append (GTK_BOX (box1),
gtk_label_new ("VBox 1 Top"));
- gtk_container_add (GTK_CONTAINER (box1),
+ gtk_box_append (GTK_BOX (box1),
box2);
- gtk_container_add (GTK_CONTAINER(box1),
+ gtk_box_append (GTK_BOX(box1),
gtk_label_new ("VBox 1 Bottom"));
- gtk_container_add (GTK_CONTAINER (box2),
+ gtk_box_append (GTK_BOX (box2),
gtk_label_new ("HBox 2 Left"));
- gtk_container_add (GTK_CONTAINER (box2),
+ gtk_box_append (GTK_BOX (box2),
box3);
- gtk_container_add (GTK_CONTAINER(box2),
+ gtk_box_append (GTK_BOX(box2),
gtk_label_new ("HBox 2 Right"));
- gtk_container_add (GTK_CONTAINER (box3),
+ gtk_box_append (GTK_BOX (box3),
gtk_label_new ("VBox 3 Top"));
colorbox = gtk_frame_new (NULL);
G_CALLBACK (on_toggle_hexpand), NULL);
gtk_frame_set_child (GTK_FRAME (colorbox), toggle);
- gtk_container_add (GTK_CONTAINER (box3), colorbox);
+ gtk_box_append (GTK_BOX (box3), colorbox);
colorbox = gtk_frame_new (NULL);
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_vexpand), NULL);
gtk_frame_set_child (GTK_FRAME (colorbox), toggle);
- gtk_container_add (GTK_CONTAINER (box3), colorbox);
- gtk_container_add (GTK_CONTAINER (box3),
+ gtk_box_append (GTK_BOX (box3), colorbox);
+ gtk_box_append (GTK_BOX (box3),
gtk_label_new ("VBox 3 Bottom"));
gtk_window_set_child (GTK_WINDOW (window), box1);
gtk_window_set_resizable (dialog, gtk_expander_get_expanded (expander));
}
-static void
-do_not_expand (GtkWidget *child, gpointer data)
-{
-}
-
static void
response_cb (GtkDialog *dialog, gint response_id, gpointer data)
{
"but not the full story.");
area = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (dialog));
- /* make the labels not expand */
- gtk_container_foreach (GTK_CONTAINER (area), do_not_expand, NULL);
expander = gtk_expander_new ("Details:");
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_expander_set_child (GTK_EXPANDER (expander), sw);
gtk_widget_set_hexpand (expander, TRUE);
gtk_widget_set_vexpand (expander, TRUE);
- gtk_container_add (GTK_CONTAINER (area), expander);
+ gtk_box_append (GTK_BOX (area), expander);
g_signal_connect (expander, "notify::expanded",
G_CALLBACK (expander_cb), dialog);
button = gtk_button_new_with_mnemonic ("_Select all");
gtk_widget_set_sensitive (button, multiple);
- gtk_container_add (GTK_CONTAINER (vbbox), button);
+ gtk_box_append (GTK_BOX (vbbox), button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_file_chooser_select_all), dialog);
g_signal_connect (dialog, "notify::select-multiple",
G_CALLBACK (notify_multiple_cb), button);
button = gtk_button_new_with_mnemonic ("_Unselect all");
- gtk_container_add (GTK_CONTAINER (vbbox), button);
+ gtk_box_append (GTK_BOX (vbbox), button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_file_chooser_unselect_all), dialog);
button = gtk_button_new_with_label ("set_current_folder (\"/nonexistent\")");
- gtk_container_add (GTK_CONTAINER (vbbox), button);
+ gtk_box_append (GTK_BOX (vbbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (set_folder_nonexistent_cb), dialog);
button = gtk_button_new_with_label ("set_current_folder (\"/usr/nonexistent\")");
- gtk_container_add (GTK_CONTAINER (vbbox), button);
+ gtk_box_append (GTK_BOX (vbbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (set_folder_existing_nonexistent_cb), dialog);
button = gtk_button_new_with_label ("set_filename (\"/nonexistent\")");
- gtk_container_add (GTK_CONTAINER (vbbox), button);
+ gtk_box_append (GTK_BOX (vbbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (set_filename_nonexistent_cb), dialog);
button = gtk_button_new_with_label ("set_filename (\"/usr/nonexistent\")");
- gtk_container_add (GTK_CONTAINER (vbbox), button);
+ gtk_box_append (GTK_BOX (vbbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (set_filename_existing_nonexistent_cb), dialog);
button = gtk_button_new_with_label ("Get selection");
- gtk_container_add (GTK_CONTAINER (vbbox), button);
+ gtk_box_append (GTK_BOX (vbbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (get_selection_cb), dialog);
button = gtk_button_new_with_label ("Get current name");
- gtk_container_add (GTK_CONTAINER (vbbox), button);
+ gtk_box_append (GTK_BOX (vbbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (get_current_name_cb), dialog);
button = gtk_button_new_with_label ("Unmap and remap");
- gtk_container_add (GTK_CONTAINER (vbbox), button);
+ gtk_box_append (GTK_BOX (vbbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (unmap_and_remap_cb), dialog);
GTK_WINDOW (gtk_widget_get_root (user_data)));
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (tests), box);
+ gtk_box_append (GTK_BOX (tests), box);
button = gtk_button_new_with_label ("Print Selected Path");
g_signal_connect (button, "clicked",
G_CALLBACK (print_selected_path_clicked_cb), user_data);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_label ("Add $PWD's Parent as Shortcut");
g_signal_connect (button, "clicked",
G_CALLBACK (add_pwds_parent_as_shortcut_clicked_cb), user_data);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_label ("Remove $PWD's Parent as Shortcut");
g_signal_connect (button, "clicked",
G_CALLBACK (del_pwds_parent_as_shortcut_clicked_cb), user_data);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_label ("Unselect all");
g_signal_connect (button, "clicked",
G_CALLBACK (unselect_all_clicked_cb), user_data);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_object_set_data (user_data, "tests-dialog", tests);
}
GFile *path;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
- gtk_container_add (GTK_CONTAINER (group_box), hbox);
+ gtk_box_append (GTK_BOX (group_box), hbox);
label = gtk_label_new_with_mnemonic (mnemonic);
gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
chooser = gtk_file_chooser_button_new (g_strconcat(chooser_title,
" - testfilechooserbutton", NULL),
G_CALLBACK (chooser_current_folder_changed_cb), NULL);
g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
- gtk_container_add (GTK_CONTAINER (hbox), chooser);
+ gtk_box_append (GTK_BOX (hbox), chooser);
button = gtk_button_new_with_label ("Tests");
g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
}
static void
gtk_widget_set_margin_end (vbox, 6);
gtk_widget_set_margin_top (vbox, 6);
gtk_widget_set_margin_bottom (vbox, 6);
- gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (win))), vbox);
+ gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (win))), vbox);
frame = gtk_frame_new ("<b>GtkFileChooserButton</b>");
gtk_label_set_use_markup (GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
gtk_widget_set_halign (frame, GTK_ALIGN_FILL);
gtk_widget_set_valign (frame, GTK_ALIGN_FILL);
gtk_frame_set_child (GTK_FRAME (frame), box);
widget = gtk_label_new ("Label");
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
switch (i % 4)
{
g_assert_not_reached ();
}
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
if (i % 5 == 0)
- gtk_container_add (GTK_CONTAINER (box), gtk_switch_new ());
+ gtk_box_append (GTK_BOX (box), gtk_switch_new ());
gtk_flow_box_insert (GTK_FLOW_BOX (flowbox), frame, -1);
if (!sensitive)
label = gtk_label_new (text);
- gtk_container_add (GTK_CONTAINER (widget), image);
- gtk_container_add (GTK_CONTAINER (widget), label);
+ gtk_box_append (GTK_BOX (widget), image);
+ gtk_box_append (GTK_BOX (widget), label);
g_object_set_data_full (G_OBJECT (widget), "id", (gpointer)g_strdup (text), g_free);
- gtk_container_add (GTK_CONTAINER (flowbox), widget);
+ gtk_box_append (GTK_BOX (flowbox), widget);
g_free (text);
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_window_set_child (GTK_WINDOW (window), hbox);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_hexpand (swindow, TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (hbox), swindow);
+ gtk_box_append (GTK_BOX (hbox), swindow);
flowbox = gtk_flow_box_new ();
gtk_widget_set_halign (flowbox, GTK_ALIGN_END);
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
flowbox_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_expander_set_child (GTK_EXPANDER (expander), flowbox_cntl);
- gtk_container_add (GTK_CONTAINER (vbox), expander);
+ gtk_box_append (GTK_BOX (vbox), expander);
widget = gtk_check_button_new_with_label ("Homogeneous");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_set_tooltip_text (widget, "Set whether the items should be displayed at the same size");
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (homogeneous_toggled), flowbox);
g_object_bind_property (widget, "active",
flowbox, "activate-on-single-click",
G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
/* Add alignment controls */
widget = gtk_combo_box_text_new ();
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_HALIGN);
gtk_widget_set_tooltip_text (widget, "Set the horizontal alignment policy");
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (horizontal_alignment_changed), flowbox);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_VALIGN);
gtk_widget_set_tooltip_text (widget, "Set the vertical alignment policy");
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (vertical_alignment_changed), flowbox);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_set_tooltip_text (widget, "Set the flowbox orientation");
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (orientation_changed), flowbox);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1);
gtk_widget_set_tooltip_text (widget, "Set the selection mode");
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (selection_mode_changed), flowbox);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MINIMUM_LENGTH);
gtk_widget_set_tooltip_text (widget, "Set the minimum amount of items per line before wrapping");
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (line_length_changed), flowbox);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MAXIMUM_LENGTH);
gtk_widget_set_tooltip_text (widget, "Set the natural amount of items per line ");
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (max_line_length_changed), flowbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
widget = gtk_label_new ("H Spacing");
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_spin_button_new_with_range (0, 30, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_CSPACING);
gtk_widget_set_tooltip_text (widget, "Set the horizontal spacing between children");
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), hbox);
+ gtk_box_append (GTK_BOX (flowbox_cntl), hbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
widget = gtk_label_new ("V Spacing");
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_spin_button_new_with_range (0, 30, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_RSPACING);
gtk_widget_set_tooltip_text (widget, "Set the vertical spacing between children");
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), hbox);
+ gtk_box_append (GTK_BOX (flowbox_cntl), hbox);
/* filtering and sorting */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_set_tooltip_text (widget, "Set whether some items should be filtered out");
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (filter_toggled), flowbox);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_set_tooltip_text (widget, "Set whether items should be sorted");
- gtk_container_add (GTK_CONTAINER (flowbox_cntl), widget);
+ gtk_box_append (GTK_BOX (flowbox_cntl), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (sort_toggled), flowbox);
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
items_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_expander_set_child (GTK_EXPANDER (expander), items_cntl);
- gtk_container_add (GTK_CONTAINER (vbox), expander);
+ gtk_box_append (GTK_BOX (vbox), expander);
/* Add Items control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_set_tooltip_text (widget, "Set the item set to use");
- gtk_container_add (GTK_CONTAINER (items_cntl), widget);
+ gtk_box_append (GTK_BOX (items_cntl), widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (items_changed), flowbox);
frame = GTK_FRAME (gtk_frame_new ("Test GtkFrame"));
gtk_widget_set_vexpand (GTK_WIDGET (frame), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), GTK_WIDGET (frame));
+ gtk_box_append (GTK_BOX (vbox), GTK_WIDGET (frame));
widget = gtk_button_new_with_label ("Hello!");
gtk_frame_set_child (GTK_FRAME (frame), widget);
grid = GTK_GRID (gtk_grid_new ());
gtk_grid_set_row_spacing (grid, 12);
gtk_grid_set_column_spacing (grid, 6);
- gtk_container_add (GTK_CONTAINER (vbox), GTK_WIDGET (grid));
+ gtk_box_append (GTK_BOX (vbox), GTK_WIDGET (grid));
xalign = gtk_frame_get_label_align (frame);
button = gtk_button_new_with_label ("Fullscreen on current monitor");
g_signal_connect (button, "clicked", G_CALLBACK (set_fullscreen_monitor_cb), GINT_TO_POINTER (GDK_FULLSCREEN_ON_CURRENT_MONITOR));
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Fullscreen on all monitors");
g_signal_connect (button, "clicked", G_CALLBACK (set_fullscreen_monitor_cb), GINT_TO_POINTER (GDK_FULLSCREEN_ON_ALL_MONITORS));
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Un-fullscreen");
g_signal_connect (button, "clicked", G_CALLBACK (remove_fullscreen_cb), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
gtk_widget_show (window);
label = gtk_label_new ("Initial Text");
gtk_widget_set_margin_top (label, 12);
gtk_widget_set_margin_bottom (label, 12);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
gtk_widget_set_halign (menubutton, GTK_ALIGN_CENTER);
{
GMenuModel *menu_model;
}
gtk_menu_button_set_popover (GTK_MENU_BUTTON (menubutton), menu);
- gtk_container_add (GTK_CONTAINER (box), menubutton);
+ gtk_box_append (GTK_BOX (box), menubutton);
gtk_widget_set_halign (button1, GTK_ALIGN_CENTER);
gtk_actionable_set_action_name (GTK_ACTIONABLE (button1), "win.change-label-button");
- gtk_container_add (GTK_CONTAINER (box), button1);
+ gtk_box_append (GTK_BOX (box), button1);
gtk_window_set_child (GTK_WINDOW (window), box);
gtk_window_set_child (GTK_WINDOW (toplevel), hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
image = gtk_image_new_from_gicon (G_ICON (pixbuf));
gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
- gtk_container_add (GTK_CONTAINER (vbox), image);
+ gtk_box_append (GTK_BOX (vbox), image);
label = gtk_label_new (NULL);
str = g_strdup_printf ("Normal icon, hash %u", g_icon_hash (G_ICON (pixbuf)));
gtk_label_set_label (GTK_LABEL (label), str);
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
otherpix = gdk_pixbuf_new_from_file ("gnome-textfile.png", NULL);
emblem = g_emblem_new (G_ICON (otherpix));
emblemed = g_emblemed_icon_new (G_ICON (pixbuf), emblem);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
image2 = gtk_image_new_from_gicon (emblemed);
gtk_image_set_icon_size (GTK_IMAGE (image2), GTK_ICON_SIZE_LARGE);
- gtk_container_add (GTK_CONTAINER (vbox), image2);
+ gtk_box_append (GTK_BOX (vbox), image2);
label = gtk_label_new (NULL);
str = g_strdup_printf ("Emblemed icon, hash %u", g_icon_hash (emblemed));
gtk_label_set_label (GTK_LABEL (label), str);
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
gtk_widget_show (toplevel);
}
label = gtk_label_new (text);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
adj = gtk_adjustment_new (0.0, 0.0, 360.0, 1.0, 12.0, 0.0);
g_signal_connect (adj, "value-changed",
G_CALLBACK (on_axis_value_change),
GINT_TO_POINTER (axis));
slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adj);
- gtk_container_add (GTK_CONTAINER (box), slider);
+ gtk_box_append (GTK_BOX (box), slider);
gtk_widget_set_hexpand (slider, TRUE);
return box;
gl_area = gtk_gl_area_new ();
gtk_widget_set_hexpand (gl_area, TRUE);
gtk_widget_set_vexpand (gl_area, TRUE);
- gtk_container_add (GTK_CONTAINER (box), gl_area);
+ gtk_box_append (GTK_BOX (box), gl_area);
g_signal_connect (gl_area, "realize", G_CALLBACK (realize), NULL);
g_signal_connect (gl_area, "unrealize", G_CALLBACK (unrealize), NULL);
g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
controls = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE);
- gtk_container_add (GTK_CONTAINER (box), controls);
+ gtk_box_append (GTK_BOX (box), controls);
gtk_widget_set_hexpand (controls, TRUE);
for (i = 0; i < N_AXIS; i++)
- gtk_container_add (GTK_CONTAINER (controls), create_axis_slider (i));
+ gtk_box_append (GTK_BOX (controls), create_axis_slider (i));
button = gtk_button_new_with_label ("Quit");
gtk_widget_set_hexpand (button, TRUE);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
gtk_widget_show (window);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
button = gtk_check_button_new_with_label ("Add Italic");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_object_set_data (G_OBJECT (button), "group", group);
g_object_set_data (G_OBJECT (button), "model", model);
G_CALLBACK (toggle_italic), treeview);
button = gtk_check_button_new_with_label ("Add Sumerian");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_object_set_data (G_OBJECT (button), "group", group);
g_object_set_data (G_OBJECT (button), "model", model);
G_CALLBACK (toggle_sumerian), NULL);
button = gtk_check_button_new_with_label ("Add Speed");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_object_set_data (G_OBJECT (button), "group", group);
g_object_set_data (G_OBJECT (button), "model", model);
model = get_model ();
tv = create_action_treeview (group);
- gtk_container_add (GTK_CONTAINER (box), tv);
+ gtk_box_append (GTK_BOX (box), tv);
buttons = create_add_remove_buttons (group, model, tv);
- gtk_container_add (GTK_CONTAINER (box), buttons);
+ gtk_box_append (GTK_BOX (box), buttons);
}
if (do_export)
gtk_menu_button_set_label (GTK_MENU_BUTTON (button), "Click here");
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), model);
gtk_widget_insert_action_group (button, "actions", group);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
}
gtk_widget_show (window);
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_free (data);
g_object_unref (provider);
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
return box;
}
grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL);
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("Above"));
- gtk_container_add (GTK_CONTAINER (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
- gtk_container_add (GTK_CONTAINER (box), grid);
- gtk_container_add (GTK_CONTAINER (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("Below"));
+ gtk_box_append (GTK_BOX (box), gtk_label_new ("Above"));
+ gtk_box_append (GTK_BOX (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (box), grid);
+ gtk_box_append (GTK_BOX (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (box), gtk_label_new ("Below"));
label = gtk_label_new ("Some text that may wrap if it has to");
gtk_label_set_width_chars (GTK_LABEL (label), 10);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_window_set_child (GTK_WINDOW (window), vbox);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("Above"));
- gtk_container_add (GTK_CONTAINER (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new ("Above"));
+ gtk_box_append (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), box);
+ gtk_box_append (GTK_BOX (vbox), box);
- gtk_container_add (GTK_CONTAINER (box), test_widget ("1", "white"));
+ gtk_box_append (GTK_BOX (box), test_widget ("1", "white"));
label = gtk_label_new ("Some ellipsizing text");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_label_set_width_chars (GTK_LABEL (label), 10);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
- gtk_container_add (GTK_CONTAINER (box), test_widget ("2", "green"));
+ gtk_box_append (GTK_BOX (box), test_widget ("2", "green"));
label = gtk_label_new ("Some text that may wrap if needed");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_width_chars (GTK_LABEL (label), 10);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
- gtk_container_add (GTK_CONTAINER (box), test_widget ("3", "red"));
+ gtk_box_append (GTK_BOX (box), test_widget ("3", "red"));
grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
- gtk_container_add (GTK_CONTAINER (vbox), grid);
+ gtk_box_append (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (vbox), grid);
gtk_grid_attach (GTK_GRID (grid), test_widget ("1", "white"), 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), test_widget ("3", "red"), 4, 0, 1, 1);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("Below"));
+ gtk_box_append (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new ("Below"));
gtk_widget_show (window);
}
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<i>Entry: </i>");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (hbox), entry);
gtk_widget_set_hexpand (hbox, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox, 0, 3, 2, 1);
gtk_widget_set_margin_start (vbox, 12);
gtk_widget_set_margin_end (vbox, 12);
gtk_widget_set_vexpand (vbox, TRUE);
- gtk_container_add (GTK_CONTAINER (content_area), vbox);
-
label = gtk_label_new (NULL);
- gtk_widget_set_vexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (content_area), vbox);
+ gtk_box_append (GTK_BOX (vbox), label);
display = gtk_widget_get_display (window);
on_composited_changed (display, NULL, GTK_LABEL (label));
g_signal_connect (display, "notify::composited", G_CALLBACK (on_composited_changed), label);
- gtk_container_add (GTK_CONTAINER (vbox), build_alpha_widgets ());
+ gtk_box_append (GTK_BOX (vbox), build_alpha_widgets ());
g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
g_signal_connect (window, "response",
static void
button_window (GtkWidget *widget,
- GtkWidget *button)
+ GtkWidget *button)
{
if (!gtk_widget_get_visible (button))
gtk_widget_show (button);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 5);
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
+
gtk_widget_set_margin_top (grid, 10);
gtk_widget_set_margin_bottom (grid, 10);
gtk_widget_set_margin_start (grid, 10);
gtk_widget_set_margin_end (grid, 10);
- gtk_container_add (GTK_CONTAINER (box1), grid);
+ gtk_box_append (GTK_BOX (box1), grid);
button[0] = gtk_button_new_with_label ("button1");
button[1] = gtk_button_new_with_mnemonic ("_button2");
}
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button[9] = gtk_button_new_with_label ("close");
gtk_widget_set_margin_top (button[9], 10);
g_signal_connect_swapped (button[9], "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (box2), button[9]);
+ gtk_box_append (GTK_BOX (box2), button[9]);
gtk_window_set_default_widget (GTK_WINDOW (window), button[9]);
}
gtk_window_set_child (GTK_WINDOW (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_toggle_button_new_with_label ("button1");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_toggle_button_new_with_label ("button2");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_toggle_button_new_with_label ("button3");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
}
gtk_widget_set_margin_end (box2, 10);
gtk_widget_set_margin_top (box2, 10);
gtk_widget_set_margin_bottom (box2, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_check_button_new_with_mnemonic ("_button1");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_check_button_new_with_label ("button2");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_check_button_new_with_label ("button3");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_check_button_new_with_label ("inconsistent");
gtk_check_button_set_inconsistent (GTK_CHECK_BUTTON (button), TRUE);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box2), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
table = create_widget_grid (GTK_TYPE_CHECK_BUTTON);
gtk_widget_set_vexpand (table, TRUE);
- gtk_container_add (GTK_CONTAINER (box2), table);
+ gtk_box_append (GTK_BOX (box2), table);
}
if (!gtk_widget_get_visible (window))
box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_radio_button_new_with_label (NULL, "button1");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"button2");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"button3");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"inconsistent");
gtk_check_button_set_inconsistent (GTK_CHECK_BUTTON (button), TRUE);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_radio_button_new_with_label (NULL, "button4");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"button5");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"button6");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
table = create_widget_grid (GTK_TYPE_RADIO_BUTTON);
- gtk_container_add (GTK_CONTAINER (box1), table);
+ gtk_box_append (GTK_BOX (box1), table);
}
if (!gtk_widget_get_visible (window))
gtk_window_set_child (GTK_WINDOW (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
statusbar = gtk_statusbar_new ();
g_signal_connect (statusbar,
button = g_object_new (gtk_button_get_type (),
"label", "push something",
NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
g_object_connect (button,
"signal::clicked", statusbar_push, statusbar,
NULL);
NULL),
"signal_after::clicked", statusbar_pop, statusbar,
NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "steal #4",
NULL),
"signal_after::clicked", statusbar_steal, statusbar,
NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "test contexts",
NULL),
"swapped_signal_after::clicked", statusbar_contexts, statusbar,
NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "push something long",
NULL),
"signal_after::clicked", statusbar_push_long, statusbar,
NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
- gtk_container_add (GTK_CONTAINER (box1), statusbar);
+ gtk_box_append (GTK_BOX (box1), box2);
+ gtk_box_append (GTK_BOX (box1), statusbar);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
}
set_selectable_recursive (GtkWidget *widget,
gboolean setting)
{
- if (GTK_IS_CONTAINER (widget))
+ if (GTK_IS_LABEL (widget))
+ gtk_label_set_selectable (GTK_LABEL (widget), setting);
+ else
{
- GList *children;
- GList *tmp;
-
- children = gtk_container_get_children (GTK_CONTAINER (widget));
- tmp = children;
- while (tmp)
- {
- set_selectable_recursive (tmp->data, setting);
+ GtkWidget *child;
- tmp = tmp->next;
- }
- g_list_free (children);
- }
- else if (GTK_IS_LABEL (widget))
- {
- gtk_label_set_selectable (GTK_LABEL (widget), setting);
+ for (child = gtk_widget_get_first_child (widget);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ set_selectable_recursive (child, setting);
}
}
button = create_sensitivity_control (hbox);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = create_selectable_control (hbox);
- gtk_container_add (GTK_CONTAINER (vbox), button);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
frame = gtk_frame_new ("Normal Label");
label = gtk_label_new ("This is a Normal label");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
frame = gtk_frame_new ("Multi-line Label");
label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
frame = gtk_frame_new ("Left Justified Label");
label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
frame = gtk_frame_new ("Right Justified Label");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
frame = gtk_frame_new ("Internationalized Label");
label = gtk_label_new (NULL);
"Japanese <span lang=\"ja\">\345\205\203\346\260\227 \351\226\213\347\231\272</span>");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
frame = gtk_frame_new ("Bidirection Label");
label = gtk_label_new ("\342\200\217Arabic \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205\n"
"\342\200\217Hebrew \327\251\327\234\327\225\327\235");
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
frame = gtk_frame_new ("Links in a label");
label = gtk_label_new ("Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
"or activated via <a href=\"keynav\">keynav</a>");
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
g_signal_connect (label, "activate-link", G_CALLBACK (activate_link), NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
frame = gtk_frame_new ("Line wrapped label");
label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
"up the entire "/* big space to test spacing */\
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
frame = gtk_frame_new ("Filled, wrapped label");
label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
frame = gtk_frame_new ("Underlined label");
label = gtk_label_new ("This label is underlined!\n"
"This one is underlined (\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257) in quite a funky fashion");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
frame = gtk_frame_new ("Markup label");
label = gtk_label_new (NULL);
g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_KEY_s);
gtk_frame_set_child (GTK_FRAME (frame), label);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
}
if (!gtk_widget_get_visible (window))
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_hexpand (drawing_area, TRUE);
gtk_widget_set_vexpand (drawing_area, TRUE);
- gtk_container_add (GTK_CONTAINER (content_area), drawing_area);
+ gtk_box_append (GTK_BOX (content_area), drawing_area);
tile_pixbuf = gdk_pixbuf_new_from_file ("marble.xpm", NULL);
gtk_window_set_child (GTK_WINDOW (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new ();
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gdk_surface = gtk_native_get_surface (GTK_NATIVE (window));
label = gtk_label_new ("Pixbuf\ntest");
box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
- gtk_container_add (GTK_CONTAINER (box3), label);
+ gtk_box_append (GTK_BOX (box3), pixbufwid);
+ gtk_box_append (GTK_BOX (box3), label);
gtk_button_set_child (GTK_BUTTON (button), box3);
button = gtk_button_new ();
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
pixbufwid = new_pixbuf ("test.xpm", gdk_surface);
label = gtk_label_new ("Pixbuf\ntest");
box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
- gtk_container_add (GTK_CONTAINER (box3), label);
+ gtk_box_append (GTK_BOX (box3), pixbufwid);
+ gtk_box_append (GTK_BOX (box3), label);
gtk_button_set_child (GTK_BUTTON (button), box3);
gtk_widget_set_sensitive (button, FALSE);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
}
gtk_window_set_child (GTK_WINDOW (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_toggle_button_new_with_label ("button1");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_widget_set_tooltip_text (button, "This is button 1");
button = gtk_toggle_button_new_with_label ("button2");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_widget_set_tooltip_text (button,
"This is button 2. This is also a really long tooltip which probably "
"Hopefully the wrapping will work correctly.");
toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
- gtk_container_add (GTK_CONTAINER (box2), toggle);
+ gtk_box_append (GTK_BOX (box2), toggle);
gtk_widget_set_tooltip_text (toggle, "Toggle TipsQuery view.");
g_object_new (gtk_button_get_type (),
"label", "[?]",
NULL);
- gtk_container_add (GTK_CONTAINER (box3), button);
+ gtk_box_append (GTK_BOX (box3), button);
gtk_widget_set_tooltip_text (button, "Start the Tooltips Inspector");
frame = g_object_new (gtk_frame_get_type (),
"label", "ToolTips Inspector",
"label_xalign", (double) 0.5,
NULL);
- gtk_container_add (GTK_CONTAINER (box2), frame);
+ gtk_box_append (GTK_BOX (box2), frame);
gtk_frame_set_child (GTK_FRAME (frame), box3);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
gtk_widget_set_tooltip_text (button, "Push this button to close window");
const gchar *text,
GtkWidget *image)
{
- gtk_container_add (GTK_CONTAINER (box),
+ gtk_box_append (GTK_BOX (box),
gtk_label_new (text));
- gtk_container_add (GTK_CONTAINER (box),
+ gtk_box_append (GTK_BOX (box),
image);
}
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (hbox), scrolled);
+ gtk_box_append (GTK_BOX (hbox), scrolled);
scrolled_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled), scrolled_box);
label = gtk_label_new ("This is \na LABEL\nwith rows");
- gtk_container_add (GTK_CONTAINER (scrolled_box), label);
+ gtk_box_append (GTK_BOX (scrolled_box), label);
list = gtk_list_box_new();
gtk_list_box_set_adjustment (GTK_LIST_BOX (list), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled)));
- gtk_container_add (GTK_CONTAINER (scrolled_box), list);
+ gtk_box_append (GTK_BOX (scrolled_box), list);
for (i = 0; i < 1000; i++)
{
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
button = gtk_button_new_with_label ("sort");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (list_sort_clicked_cb), list);
button = gtk_button_new_with_label ("filter odd");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (list_filter_odd_clicked_cb), list);
button = gtk_button_new_with_label ("filter all");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (list_filter_all_clicked_cb), list);
button = gtk_button_new_with_label ("unfilter");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (list_unfilter_clicked_cb), list);
button = gtk_button_new_with_label ("add placeholder");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (add_placeholder_clicked_cb), list);
button = gtk_button_new_with_label ("remove placeholder");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (remove_placeholder_clicked_cb), list);
}
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_hexpand (box, TRUE);
gtk_widget_set_vexpand (box, TRUE);
- gtk_container_add (GTK_CONTAINER (content_area), box);
+ gtk_box_append (GTK_BOX (content_area), box);
button = gtk_button_new_with_mnemonic ("Button 1 (_a)");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = accel_button_new ("Button 7", "<Alt><Shift>b");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = accel_button_new ("Button 8", "<Alt>d");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = accel_button_new ("Button 9", "<Alt>Cyrillic_ve");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_mnemonic ("Button 10 (_1)");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = accel_button_new ("Button 12", "<Super>a");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = accel_button_new ("Button 13", "<Hyper>a");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = accel_button_new ("Button 14", "<Meta>a");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
g_signal_connect (window, "response", G_CALLBACK (gtk_window_destroy), NULL);
/* Pack widgets */
gtk_window_set_child (GTK_WINDOW (window), box1);
- gtk_container_add (GTK_CONTAINER (box1), frame1);
+ gtk_box_append (GTK_BOX (box1), frame1);
gtk_frame_set_child (GTK_FRAME (frame1), box2);
- gtk_container_add (GTK_CONTAINER (box2), btnColor);
- gtk_container_add (GTK_CONTAINER (box2), btnFile);
- gtk_container_add (GTK_CONTAINER (box1), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
- gtk_container_add (GTK_CONTAINER (box1), btnClose);
+ gtk_box_append (GTK_BOX (box2), btnColor);
+ gtk_box_append (GTK_BOX (box2), btnFile);
+ gtk_box_append (GTK_BOX (box1), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (box1), btnClose);
/* connect signals */
g_signal_connect_swapped (btnClose, "clicked",
GtkWidget *scrollwin)
{
g_object_ref (scrollwin);
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (scrollwin)), scrollwin);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (scrollwin)), scrollwin);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw_parent), scrollwin);
g_object_unref (scrollwin);
if (sw_parent)
{
g_object_ref (scrollwin);
- gtk_window_set_child (GTK_WINDOW (gtk_widget_get_parent (scrollwin)), NULL);
- gtk_container_add (GTK_CONTAINER (sw_parent), scrollwin);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (scrollwin)), scrollwin);
+ gtk_window_set_child (GTK_WINDOW (sw_float_parent), scrollwin);
g_object_unref (scrollwin);
gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
g_object_ref (scrollwin);
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (scrollwin)), scrollwin);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (scrollwin)), scrollwin);
gtk_window_set_child (GTK_WINDOW (sw_float_parent), scrollwin);
g_object_unref (scrollwin);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (content_area), scrolled_window);
+ gtk_box_append (GTK_BOX (content_area), scrolled_window);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
gtk_widget_set_margin_bottom (box2, 10);
gtk_widget_set_margin_start (box2, 10);
gtk_widget_set_margin_end (box2, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
- gtk_container_add (GTK_CONTAINER (box2), hbox);
+ gtk_box_append (GTK_BOX (box2), hbox);
entry = gtk_entry_new ();
gtk_editable_set_text (GTK_EDITABLE (entry), "hello world \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205");
gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
gtk_widget_set_hexpand (entry, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (hbox), entry);
cb = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ());
cb_entry = gtk_combo_box_get_child (GTK_COMBO_BOX (cb));
gtk_editable_set_text (GTK_EDITABLE (cb_entry), "hello world \n\n\n foo");
gtk_editable_select_region (GTK_EDITABLE (cb_entry), 0, -1);
- gtk_container_add (GTK_CONTAINER (box2), GTK_WIDGET (cb));
+ gtk_box_append (GTK_BOX (box2), GTK_WIDGET (cb));
sensitive_check = gtk_check_button_new_with_label ("Sensitive");
- gtk_container_add (GTK_CONTAINER (box2), sensitive_check);
+ gtk_box_append (GTK_BOX (box2), sensitive_check);
g_signal_connect (sensitive_check, "toggled",
G_CALLBACK (entry_toggle_sensitive), entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
has_frame_check = gtk_check_button_new_with_label("Has Frame");
- gtk_container_add (GTK_CONTAINER (box2), has_frame_check);
+ gtk_box_append (GTK_BOX (box2), has_frame_check);
g_signal_connect (has_frame_check, "toggled",
G_CALLBACK (entry_toggle_frame), entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
progress_check = gtk_check_button_new_with_label("Show Progress");
- gtk_container_add (GTK_CONTAINER (box2), progress_check);
+ gtk_box_append (GTK_BOX (box2), progress_check);
g_signal_connect (progress_check, "toggled",
G_CALLBACK (entry_toggle_progress), entry);
progress_check = gtk_check_button_new_with_label("Pulse Progress");
- gtk_container_add (GTK_CONTAINER (box2), progress_check);
+ gtk_box_append (GTK_BOX (box2), progress_check);
g_signal_connect (progress_check, "toggled",
G_CALLBACK (entry_toggle_pulse), entry);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_widget_set_margin_top (box2, 10);
gtk_widget_set_margin_bottom (box2, 10);
gtk_widget_set_margin_start (box2, 10);
gtk_widget_set_margin_end (box2, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
}
expander = gtk_expander_new ("The Hidden");
- gtk_container_add (GTK_CONTAINER (box1), expander);
+ gtk_box_append (GTK_BOX (box1), expander);
hidden = gtk_label_new ("Revealed!");
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (content_area), vbox);
+ gtk_box_append (GTK_BOX (content_area), vbox);
grid = gtk_grid_new ();
- gtk_container_add (GTK_CONTAINER (vbox), grid);
+ gtk_box_append (GTK_BOX (content_area), grid);
gtk_grid_set_row_spacing (GTK_GRID (grid), 5);
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
g_object_unref (vgroup2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (content_area), hbox);
spin_button = gtk_spin_button_new_with_range (1, 100, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
gtk_widget_set_hexpand (spin_button, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), spin_button);
+ gtk_box_append (GTK_BOX (hbox), spin_button);
g_signal_connect (spin_button, "value_changed",
G_CALLBACK (size_group_hsize_changed), main_button);
spin_button = gtk_spin_button_new_with_range (1, 100, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
gtk_widget_set_hexpand (spin_button, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), spin_button);
+ gtk_box_append (GTK_BOX (hbox), spin_button);
g_signal_connect (spin_button, "value_changed",
G_CALLBACK (size_group_vsize_changed), main_button);
gtk_window_set_child (GTK_WINDOW (window), main_vbox);
frame = gtk_frame_new ("Not accelerated");
- gtk_container_add (GTK_CONTAINER (main_vbox), frame);
+ gtk_box_append (GTK_BOX (main_vbox), frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (frame), vbox);
/* Time, month, hex spinners */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_hexpand (vbox2, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), vbox2);
+ gtk_box_append (GTK_BOX (hbox), vbox2);
label = gtk_label_new ("Time :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox2), label);
+ gtk_box_append (GTK_BOX (vbox2), label);
adjustment = gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
spinner = gtk_spin_button_new (adjustment, 0, 0);
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_editable_set_width_chars (GTK_EDITABLE (spinner), 5);
- gtk_container_add (GTK_CONTAINER (vbox2), spinner);
+ gtk_box_append (GTK_BOX (vbox2), spinner);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_hexpand (vbox2, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), vbox2);
+ gtk_box_append (GTK_BOX (hbox), vbox2);
label = gtk_label_new ("Month :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox2), label);
+ gtk_box_append (GTK_BOX (vbox2), label);
adjustment = gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
5.0, 0.0);
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_editable_set_width_chars (GTK_EDITABLE (spinner), 9);
- gtk_container_add (GTK_CONTAINER (vbox2), spinner);
+ gtk_box_append (GTK_BOX (vbox2), spinner);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_hexpand (vbox2, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), vbox2);
+ gtk_box_append (GTK_BOX (hbox), vbox2);
label = gtk_label_new ("Hex :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox2), label);
+ gtk_box_append (GTK_BOX (vbox2), label);
adjustment = gtk_adjustment_new (0, 0, 255, 1, 16, 0);
spinner = gtk_spin_button_new (adjustment, 0, 0);
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_editable_set_width_chars (GTK_EDITABLE (spinner), 4);
- gtk_container_add (GTK_CONTAINER (vbox2), spinner);
+ gtk_box_append (GTK_BOX (vbox2), spinner);
frame = gtk_frame_new ("Accelerated");
- gtk_container_add (GTK_CONTAINER (main_vbox), frame);
+ gtk_box_append (GTK_BOX (main_vbox), frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_frame_set_child (GTK_FRAME (frame), vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (hbox), vbox2);
+ gtk_box_append (GTK_BOX (hbox), vbox2);
label = gtk_label_new ("Value :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox2), label);
+ gtk_box_append (GTK_BOX (vbox2), label);
adjustment = gtk_adjustment_new (0.0, -10000.0, 10000.0,
0.5, 100.0, 0.0);
spinner1 = gtk_spin_button_new (adjustment, 1.0, 2);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox2), spinner1);
+ gtk_box_append (GTK_BOX (vbox2), spinner1);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (hbox), vbox2);
+ gtk_box_append (GTK_BOX (hbox), vbox2);
label = gtk_label_new ("Digits :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox2), label);
+ gtk_box_append (GTK_BOX (vbox2), label);
adjustment = gtk_adjustment_new (2, 1, 15, 1, 1, 0);
spinner2 = gtk_spin_button_new (adjustment, 0.0, 0);
g_signal_connect (adjustment, "value_changed",
G_CALLBACK (change_digits),
spinner2);
- gtk_container_add (GTK_CONTAINER (vbox2), spinner2);
+ gtk_box_append (GTK_BOX (vbox2), spinner2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
g_signal_connect (button, "clicked",
G_CALLBACK (toggle_snap),
spinner1);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
button = gtk_check_button_new_with_label ("Numeric only input mode");
g_signal_connect (button, "clicked",
G_CALLBACK (toggle_numeric),
spinner1);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
val_label = gtk_label_new ("");
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_button_new_with_label ("Value as Int");
gtk_widget_set_hexpand (button, TRUE);
g_signal_connect (button, "clicked",
G_CALLBACK (get_value),
GINT_TO_POINTER (1));
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_button_new_with_label ("Value as Float");
gtk_widget_set_hexpand (button, TRUE);
g_signal_connect (button, "clicked",
G_CALLBACK (get_value),
GINT_TO_POINTER (2));
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
- gtk_container_add (GTK_CONTAINER (vbox), val_label);
+ gtk_box_append (GTK_BOX (vbox), val_label);
gtk_label_set_text (GTK_LABEL (val_label), "0");
frame = gtk_frame_new ("Using Convenience Constructor");
- gtk_container_add (GTK_CONTAINER (main_vbox), frame);
+ gtk_box_append (GTK_BOX (main_vbox), frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_frame_set_child (GTK_FRAME (frame), hbox);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
g_signal_connect (spinner, "value_changed",
G_CALLBACK (get_spin_value), val_label);
- gtk_container_add (GTK_CONTAINER (hbox), spinner);
- gtk_container_add (GTK_CONTAINER (hbox), val_label);
+ gtk_box_append (GTK_BOX (hbox), spinner);
+ gtk_box_append (GTK_BOX (hbox), val_label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (main_vbox), hbox);
+ gtk_box_append (GTK_BOX (main_vbox), hbox);
button = gtk_button_new_with_label ("Close");
gtk_widget_set_hexpand (button, TRUE);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
}
if (!gtk_widget_get_visible (window))
static void
change_cursor_theme (GtkWidget *widget,
- gpointer data)
+ gpointer data)
{
#if defined(GDK_WINDOWING_X11) || defined (GDK_WINDOWING_WAYLAND)
const gchar *theme;
gint size;
- GList *children;
GdkDisplay *display;
+ GtkWidget *entry;
+ GtkWidget *spin;
- children = gtk_container_get_children (GTK_CONTAINER (data));
-
- theme = gtk_editable_get_text (GTK_EDITABLE (children->next->data));
- size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
+ entry = gtk_widget_get_next_sibling (gtk_widget_get_first_child (GTK_WIDGET (data)));
+ spin = gtk_widget_get_next_sibling (entry);
- g_list_free (children);
+ theme = gtk_editable_get_text (GTK_EDITABLE (entry));
+ size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin));
display = gtk_widget_get_display (widget);
#ifdef GDK_WINDOWING_X11
"homogeneous", FALSE,
"spacing", 5,
NULL);
- gtk_container_add (GTK_CONTAINER (main_vbox), vbox);
+ gtk_box_append (GTK_BOX (main_vbox), vbox);
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_DISPLAY (gtk_widget_get_display (vbox)))
gtk_widget_set_margin_bottom (hbox, 5);
gtk_widget_set_margin_start (hbox, 5);
gtk_widget_set_margin_end (hbox, 5);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Cursor Theme:");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
entry = gtk_entry_new ();
gtk_editable_set_text (GTK_EDITABLE (entry), "default");
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (hbox), entry);
size = gtk_spin_button_new_with_range (1.0, 128.0, 1.0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (size), 24.0);
gtk_widget_set_hexpand (size, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), size);
+ gtk_box_append (GTK_BOX (hbox), size);
g_signal_connect (entry, "changed",
G_CALLBACK (change_cursor_theme), hbox);
gtk_widget_set_margin_bottom (hbox, 5);
gtk_widget_set_margin_start (hbox, 5);
gtk_widget_set_margin_end (hbox, 5);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Cursor Name:");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
entry = gtk_entry_new ();
completion = gtk_entry_completion_new ();
gtk_entry_set_completion (GTK_ENTRY (entry), completion);
g_object_unref (model);
gtk_widget_set_hexpand (entry, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (hbox), entry);
frame =
g_object_new (gtk_frame_get_type (),
"label_xalign", 0.5,
"label", "Cursor Area",
NULL);
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
darea = gtk_drawing_area_new ();
gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (darea), 80);
any = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (main_vbox), any);
+ gtk_box_append (GTK_BOX (main_vbox), any);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_margin_top (hbox, 10);
gtk_widget_set_margin_bottom (hbox, 10);
gtk_widget_set_margin_start (hbox, 10);
gtk_widget_set_margin_end (hbox, 10);
- gtk_container_add (GTK_CONTAINER (main_vbox), hbox);
+ gtk_box_append (GTK_BOX (main_vbox), hbox);
button = gtk_button_new_with_label ("Close");
gtk_widget_set_hexpand (button, TRUE);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
gtk_widget_show (window);
gtk_window_set_child (GTK_WINDOW (window), hbox);
label = gtk_label_new ("Pick a color");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
picker = gtk_color_button_new ();
gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (picker), TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), picker);
+ gtk_box_append (GTK_BOX (hbox), picker);
}
if (!gtk_widget_get_visible (window))
orientable_toggle_orientation (GtkOrientable *orientable)
{
GtkOrientation orientation;
+ GtkWidget *child;
orientation = gtk_orientable_get_orientation (orientable);
gtk_orientable_set_orientation (orientable,
GTK_ORIENTATION_VERTICAL :
GTK_ORIENTATION_HORIZONTAL);
- if (GTK_IS_CONTAINER (orientable))
- {
- GList *children;
- GList *child;
-
- children = gtk_container_get_children (GTK_CONTAINER (orientable));
-
- for (child = children; child; child = child->next)
- {
- if (GTK_IS_ORIENTABLE (child->data))
- orientable_toggle_orientation (child->data);
- }
- g_list_free (children);
+ for (child = gtk_widget_get_first_child (GTK_WIDGET (orientable));
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ {
+ if (GTK_IS_ORIENTABLE (child))
+ orientable_toggle_orientation (GTK_ORIENTABLE (child));
}
}
static void
set_direction_recurse (GtkWidget *widget,
- gpointer data)
+ gpointer data)
{
GtkTextDirection *dir = data;
-
+ GtkWidget *child;
+
gtk_widget_set_direction (widget, *dir);
- if (GTK_IS_CONTAINER (widget))
- gtk_container_foreach (GTK_CONTAINER (widget),
- set_direction_recurse,
- data);
+ for (child = gtk_widget_get_first_child (widget);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
+ set_direction_recurse (child, data);
}
static GtkWidget *
GtkWidget *forward_button = gtk_button_new_with_label ("Forward");
gtk_frame_set_child (GTK_FRAME (frame), bbox);
- gtk_container_add (GTK_CONTAINER (bbox), back_button);
- gtk_container_add (GTK_CONTAINER (bbox), forward_button);
+ gtk_box_append (GTK_BOX (bbox), back_button);
+ gtk_box_append (GTK_BOX (bbox), forward_button);
set_direction_recurse (frame, &text_dir);
gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
- gtk_container_add (GTK_CONTAINER (content_area), check_button);
+ gtk_box_append (GTK_BOX (content_area), check_button);
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
G_CALLBACK (flipping_toggled_cb), NULL);
check_button = gtk_check_button_new_with_label ("Toggle orientation of all boxes");
- gtk_container_add (GTK_CONTAINER (content_area), check_button);
+ gtk_box_append (GTK_BOX (content_area), check_button);
g_signal_connect (check_button, "toggled",
G_CALLBACK (flipping_orientation_toggled_cb), NULL);
- gtk_container_add (GTK_CONTAINER (content_area),
+ gtk_box_append (GTK_BOX (content_area),
create_forward_back ("Default", GTK_TEXT_DIR_NONE));
- gtk_container_add (GTK_CONTAINER (content_area),
+ gtk_box_append (GTK_BOX (content_area),
create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR));
- gtk_container_add (GTK_CONTAINER (content_area),
+ gtk_box_append (GTK_BOX (content_area),
create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL));
gtk_dialog_add_button (GTK_DIALOG (window), "Close", GTK_RESPONSE_CLOSE);
gtk_window_set_child (GTK_WINDOW (window), hbox);
label = gtk_label_new ("Pick a font");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
picker = gtk_font_button_new ();
gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), picker);
+ gtk_box_append (GTK_BOX (hbox), picker);
}
if (!gtk_widget_get_visible (window))
dialog_response_cb (GtkWidget *widget, gint response, gpointer unused)
{
GtkWidget *content_area;
- GList *l, *children;
+ GtkWidget *child;
if (response == GTK_RESPONSE_APPLY)
{
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_window));
- children = gtk_container_get_children (GTK_CONTAINER (content_area));
- for (l = children; l; l = l->next)
+ for (child = gtk_widget_get_first_child (content_area);
+ child != NULL;
+ child = gtk_widget_get_next_sibling (child))
{
- if (GTK_IS_LABEL (l->data))
+ if (GTK_IS_LABEL (child))
{
- gtk_container_remove (GTK_CONTAINER (content_area), l->data);
+ gtk_box_remove (GTK_BOX (content_area), child);
break;
}
}
/* no label removed, so add one */
- if (l == NULL)
+ if (child == NULL)
{
GtkWidget *label;
gtk_widget_set_margin_end (label, 10);
gtk_widget_set_margin_top (label, 10);
gtk_widget_set_margin_bottom (label, 10);
- gtk_container_add (GTK_CONTAINER (content_area),
- label);
+ gtk_box_append (GTK_BOX (content_area), label);
}
-
- g_list_free (children);
}
}
gtk_window_set_child (GTK_WINDOW (window), vbox);
frame = gtk_frame_new ("Select display");
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 3);
applyb = gtk_button_new_with_mnemonic ("_Apply");
cancelb = gtk_button_new_with_mnemonic ("_Cancel");
- gtk_container_add (GTK_CONTAINER (vbox), bbox);
+ gtk_box_append (GTK_BOX (vbox), bbox);
- gtk_container_add (GTK_CONTAINER (bbox), applyb);
- gtk_container_add (GTK_CONTAINER (bbox), cancelb);
+ gtk_box_append (GTK_BOX (bbox), applyb);
+ gtk_box_append (GTK_BOX (bbox), cancelb);
scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
gtk_scale_set_digits (GTK_SCALE (scale), 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
- gtk_container_add (GTK_CONTAINER (box2), scale);
+ gtk_box_append (GTK_BOX (box2), scale);
scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
- gtk_container_add (GTK_CONTAINER (box2), scrollbar);
+ gtk_box_append (GTK_BOX (box2), scrollbar);
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_scale_set_format_value_func (GTK_SCALE (scale),
(GtkScaleFormatValueFunc) reformat_value,
NULL, NULL);
- gtk_container_add (GTK_CONTAINER (box2), scale);
+ gtk_box_append (GTK_BOX (box2), scale);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_size_request (scale, -1, 200);
gtk_scale_set_digits (GTK_SCALE (scale), 2);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), scale);
+ gtk_box_append (GTK_BOX (hbox), scale);
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
gtk_widget_set_size_request (scale, -1, 200);
gtk_scale_set_digits (GTK_SCALE (scale), 2);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), scale);
+ gtk_box_append (GTK_BOX (hbox), scale);
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_scale_set_format_value_func (GTK_SCALE (scale),
(GtkScaleFormatValueFunc) reformat_value,
NULL, NULL);
- gtk_container_add (GTK_CONTAINER (hbox), scale);
+ gtk_box_append (GTK_BOX (hbox), scale);
- gtk_container_add (GTK_CONTAINER (box2), hbox);
+ gtk_box_append (GTK_BOX (box2), hbox);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
}
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_check_button_new_with_label ("Fill Tab");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (button, "toggled",
G_CALLBACK (tab_fill), child);
button = gtk_check_button_new_with_label ("Expand Tab");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "toggled",
G_CALLBACK (tab_expand), child);
pixwid = gtk_image_new_from_pixbuf (book_closed);
g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
- gtk_container_add (GTK_CONTAINER (label_box), pixwid);
+ gtk_box_append (GTK_BOX (label_box), pixwid);
gtk_widget_set_margin_start (pixwid, 3);
gtk_widget_set_margin_end (pixwid, 3);
gtk_widget_set_margin_bottom (pixwid, 1);
gtk_widget_set_margin_top (pixwid, 1);
label = gtk_label_new_with_mnemonic (accel_buffer);
- gtk_container_add (GTK_CONTAINER (label_box), label);
+ gtk_box_append (GTK_BOX (label_box), label);
menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
pixwid = gtk_image_new_from_pixbuf (book_closed);
g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
- gtk_container_add (GTK_CONTAINER (menu_box), pixwid);
+ gtk_box_append (GTK_BOX (menu_box), pixwid);
gtk_widget_set_margin_start (pixwid, 3);
gtk_widget_set_margin_end (pixwid, 3);
gtk_widget_set_margin_bottom (pixwid, 1);
gtk_widget_set_margin_top (pixwid, 1);
label = gtk_label_new (buffer);
- gtk_container_add (GTK_CONTAINER (menu_box), label);
+ gtk_box_append (GTK_BOX (menu_box), label);
gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
}
G_CALLBACK (page_switch), NULL);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
gtk_widget_set_vexpand (sample_notebook, TRUE);
- gtk_container_add (GTK_CONTAINER (box1), sample_notebook);
+ gtk_box_append (GTK_BOX (box1), sample_notebook);
gtk_widget_realize (sample_notebook);
create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_check_button_new_with_label ("popup menu");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
g_signal_connect (button, "clicked",
G_CALLBACK (notebook_popup),
sample_notebook);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
label = gtk_label_new ("Notebook Style :");
- gtk_container_add (GTK_CONTAINER (box2), label);
+ gtk_box_append (GTK_BOX (box2), label);
omenu = build_option_menu (items, G_N_ELEMENTS (items), 0,
notebook_type_changed,
sample_notebook);
- gtk_container_add (GTK_CONTAINER (box2), omenu);
+ gtk_box_append (GTK_BOX (box2), omenu);
button = gtk_button_new_with_label ("Show all Pages");
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
g_signal_connect (button, "clicked",
G_CALLBACK (show_all_pages), sample_notebook);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new_with_label ("prev");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_notebook_prev_page),
sample_notebook);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_button_new_with_label ("next");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_notebook_next_page),
sample_notebook);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_button_new_with_label ("rotate");
g_signal_connect (button, "clicked",
G_CALLBACK (rotate_notebook), sample_notebook);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (box1), button);
+ gtk_box_append (GTK_BOX (box1), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
}
gtk_window_set_child (GTK_WINDOW (window), vbox);
vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
- gtk_container_add (GTK_CONTAINER (vbox), vpaned);
+ gtk_box_append (GTK_BOX (vbox), vpaned);
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_start_child (GTK_PANED (vpaned), hpaned);
/* Now create toggle buttons to control sizing */
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
create_pane_options (GTK_PANED (hpaned),
"Horizontal",
"Left",
"Right"));
- gtk_container_add (GTK_CONTAINER (vbox),
+ gtk_box_append (GTK_BOX (vbox),
create_pane_options (GTK_PANED (vpaned),
"Vertical",
"Top",
gtk_frame_set_child (GTK_FRAME (frame1), vbox1);
button7 = gtk_button_new_with_label ("button7");
- gtk_container_add (GTK_CONTAINER (vbox1), button7);
+ gtk_box_append (GTK_BOX (vbox1), button7);
button8 = gtk_button_new_with_label ("button8");
- gtk_container_add (GTK_CONTAINER (vbox1), button8);
+ gtk_box_append (GTK_BOX (vbox1), button8);
button9 = gtk_button_new_with_label ("button9");
- gtk_container_add (GTK_CONTAINER (vbox1), button9);
+ gtk_box_append (GTK_BOX (vbox1), button9);
vpaned1 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_set_end_child (GTK_PANED (hpaned1), vpaned1);
gtk_frame_set_child (GTK_FRAME (frame5), hbox1);
button5 = gtk_button_new_with_label ("button5");
- gtk_container_add (GTK_CONTAINER (hbox1), button5);
+ gtk_box_append (GTK_BOX (hbox1), button5);
button6 = gtk_button_new_with_label ("button6");
- gtk_container_add (GTK_CONTAINER (hbox1), button6);
+ gtk_box_append (GTK_BOX (hbox1), button6);
frame3 = gtk_frame_new (NULL);
gtk_paned_set_end_child (GTK_PANED (vpaned1), frame3);
gtk_paned_set_shrink_end_child (GTK_PANED (hpaned2), TRUE);
vpaned2 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
- gtk_container_add (GTK_CONTAINER (hbox2), vpaned2);
+ gtk_box_append (GTK_BOX (hbox2), vpaned2);
frame7 = gtk_frame_new (NULL);
gtk_paned_set_start_child (GTK_PANED (vpaned2), frame7);
gtk_frame_set_child (GTK_FRAME (frame8), button11);
button10 = gtk_button_new_with_label ("button10");
- gtk_container_add (GTK_CONTAINER (hbox2), button10);
+ gtk_box_append (GTK_BOX (hbox2), button10);
return window2;
}
gtk_window_set_child (GTK_WINDOW (window3), vbox2);
label1 = gtk_label_new ("Three panes nested inside each other");
- gtk_container_add (GTK_CONTAINER (vbox2), label1);
+ gtk_box_append (GTK_BOX (vbox2), label1);
hpaned3 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (vbox2), hpaned3);
+ gtk_box_append (GTK_BOX (vbox2), hpaned3);
frame9 = gtk_frame_new (NULL);
gtk_paned_set_start_child (GTK_PANED (hpaned3), frame9);
gtk_window_set_child (GTK_WINDOW (window4), vbox3);
label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n - vpaned\n - vpaned\n - vpaned\n");
- gtk_container_add (GTK_CONTAINER (vbox3), label2);
+ gtk_box_append (GTK_BOX (vbox3), label2);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
hpaned6 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (vbox3), hpaned6);
+ gtk_box_append (GTK_BOX (vbox3), hpaned6);
vpaned3 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_set_start_child (GTK_PANED (hpaned6), vpaned3);
gtk_paned_set_shrink_end_child (GTK_PANED (hpaned6), TRUE);
vpaned4 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
- gtk_container_add (GTK_CONTAINER (hbox3), vpaned4);
+ gtk_box_append (GTK_BOX (hbox3), vpaned4);
button21 = gtk_button_new_with_label ("button21");
gtk_paned_set_start_child (GTK_PANED (vpaned4), button21);
gtk_paned_set_shrink_end_child (GTK_PANED (vpaned4), TRUE);
vpaned5 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
- gtk_container_add (GTK_CONTAINER (hbox3), vpaned5);
+ gtk_box_append (GTK_BOX (hbox3), vpaned5);
button23 = gtk_button_new_with_label ("button23");
gtk_paned_set_start_child (GTK_PANED (vpaned5), button23);
gtk_paned_set_shrink_end_child (GTK_PANED (vpaned5), TRUE);
vpaned6 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
- gtk_container_add (GTK_CONTAINER (hbox3), vpaned6);
+ gtk_box_append (GTK_BOX (hbox3), vpaned6);
button25 = gtk_button_new_with_label ("button25");
gtk_paned_set_start_child (GTK_PANED (vpaned6), button25);
label = gtk_label_new ("Try iconizing me!");
gtk_widget_set_size_request (label, 150, 50);
- gtk_container_add (GTK_CONTAINER (box1), label);
+ gtk_box_append (GTK_BOX (box1), label);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new_with_label ("close");
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
}
label = gtk_label_new ("<no window state events received>");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
g_object_set_data (G_OBJECT (label), "title", (gpointer)gtk_window_get_title (GTK_WINDOW (window)));
g_signal_connect_object (gtk_native_get_surface (GTK_NATIVE (window)), "notify::state",
G_CALLBACK (gtk_window_unminimize),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_button_new_with_label ("Minimize");
g_signal_connect_object (button,
G_CALLBACK (gtk_window_minimize),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_button_new_with_label ("Fullscreen");
g_signal_connect_object (button,
G_CALLBACK (gtk_window_fullscreen),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_button_new_with_label ("Unfullscreen");
g_signal_connect_object (button,
G_CALLBACK (gtk_window_unfullscreen),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_button_new_with_label ("Present");
g_signal_connect_object (button,
G_CALLBACK (gtk_window_present),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_button_new_with_label ("Show");
g_signal_connect_object (button,
G_CALLBACK (gtk_widget_show),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
return hbox;
}
G_CALLBACK (gtk_window_maximize),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Unmaximize");
g_signal_connect_object (button,
G_CALLBACK (gtk_window_unmaximize),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Minimize");
g_signal_connect_object (button,
G_CALLBACK (gtk_window_minimize),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Fullscreen");
g_signal_connect_object (button,
G_CALLBACK (gtk_window_fullscreen),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Unfullscreen");
g_signal_connect_object (button,
G_CALLBACK (gtk_window_unfullscreen),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Hide (withdraw)");
g_signal_connect_object (button,
G_CALLBACK (gtk_widget_hide),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
return vbox;
}
gtk_widget_realize (normal);
label = tracking_label (iconified);
- gtk_container_add (GTK_CONTAINER (box1), label);
+ gtk_box_append (GTK_BOX (box1), label);
label = tracking_label (normal);
- gtk_container_add (GTK_CONTAINER (box1), label);
+ gtk_box_append (GTK_BOX (box1), label);
gtk_widget_show (iconified);
gtk_widget_show (normal);
gtk_window_set_child (GTK_WINDOW (control_window), vbox);
label = gtk_label_new ("<no size>");
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
adjustment = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
spin = gtk_spin_button_new (adjustment, 0, 0);
- gtk_container_add (GTK_CONTAINER (vbox), spin);
+ gtk_box_append (GTK_BOX (vbox), spin);
g_object_set_data (G_OBJECT (control_window), "spin1", spin);
adjustment = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
spin = gtk_spin_button_new (adjustment, 0, 0);
- gtk_container_add (GTK_CONTAINER (vbox), spin);
+ gtk_box_append (GTK_BOX (vbox), spin);
g_object_set_data (G_OBJECT (control_window), "spin2", spin);
G_CALLBACK (gtk_widget_queue_resize),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Resize");
g_signal_connect (button,
"clicked",
G_CALLBACK (set_size_callback),
control_window);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Set default size");
g_signal_connect (button,
"clicked",
G_CALLBACK (set_default_size_callback),
control_window);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Unset default size");
g_signal_connect (button,
"clicked",
G_CALLBACK (unset_default_size_callback),
control_window);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Set size request");
g_signal_connect (button,
"clicked",
G_CALLBACK (set_size_request_callback),
control_window);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_label ("Unset size request");
g_signal_connect (button,
"clicked",
G_CALLBACK (unset_size_request_callback),
control_window);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_check_button_new_with_label ("Allow resize");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
"toggled",
G_CALLBACK (resizable_callback),
control_window);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_mnemonic ("_Show");
g_signal_connect_object (button,
G_CALLBACK (gtk_widget_show),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
button = gtk_button_new_with_mnemonic ("_Hide");
g_signal_connect_object (button,
G_CALLBACK (gtk_widget_hide),
window,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
return control_window;
}
gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (content_area), vbox);
+ gtk_box_append (GTK_BOX (content_area), vbox);
frame = gtk_frame_new ("Progress");
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_frame_set_child (GTK_FRAME (frame), vbox2);
PANGO_ELLIPSIZE_MIDDLE);
gtk_widget_set_halign (pdata->pbar, GTK_ALIGN_CENTER);
gtk_widget_set_valign (pdata->pbar, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox2), pdata->pbar);
+ gtk_box_append (GTK_BOX (vbox2), pdata->pbar);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER);
gtk_widget_set_valign (hbox, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (vbox2), hbox);
+ gtk_box_append (GTK_BOX (vbox2), hbox);
label = gtk_label_new ("Label updated by user :");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
pdata->label = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (hbox), pdata->label);
+ gtk_box_append (GTK_BOX (hbox), pdata->label);
frame = gtk_frame_new ("Options");
- gtk_container_add (GTK_CONTAINER (vbox), frame);
+ gtk_box_append (GTK_BOX (vbox), frame);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_frame_set_child (GTK_FRAME (frame), vbox2);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
- gtk_container_add (GTK_CONTAINER (vbox2), grid);
+ gtk_box_append (GTK_BOX (vbox2), grid);
label = gtk_label_new ("Orientation :");
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 2, 1, 1);
label = gtk_label_new ("Text: ");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
pdata->entry = gtk_entry_new ();
gtk_widget_set_hexpand (pdata->entry, TRUE);
g_signal_connect (pdata->entry, "changed",
G_CALLBACK (entry_changed),
pdata);
- gtk_container_add (GTK_CONTAINER (hbox), pdata->entry);
+ gtk_box_append (GTK_BOX (hbox), pdata->entry);
gtk_widget_set_size_request (pdata->entry, 100, -1);
label = gtk_label_new ("Ellipsize text :");
gtk_widget_set_margin_end (label, 10);
gtk_widget_set_margin_top (label, 10);
gtk_widget_set_margin_bottom (label, 10);
- gtk_container_add (GTK_CONTAINER (content_area), label);
+ gtk_box_append (GTK_BOX (content_area), label);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_window_destroy),
window);
- gtk_container_add (GTK_CONTAINER (action_area), button);
+ gtk_box_append (GTK_BOX (action_area), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
button = gtk_button_new_with_label ("start");
g_signal_connect (button, "clicked",
G_CALLBACK(start_timeout_test),
label);
- gtk_container_add (GTK_CONTAINER (action_area), button);
+ gtk_box_append (GTK_BOX (action_area), button);
button = gtk_button_new_with_label ("stop");
g_signal_connect (button, "clicked",
G_CALLBACK (stop_timeout_test),
NULL);
- gtk_container_add (GTK_CONTAINER (action_area), button);
+ gtk_box_append (GTK_BOX (action_area), button);
}
if (!gtk_widget_get_visible (window))
gtk_window_set_child (GTK_WINDOW (window), box);
label = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
combo = gtk_combo_box_text_new ();
g_signal_connect (combo, "changed",
G_CALLBACK (native_action_changed), native);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), GTK_FILE_CHOOSER_ACTION_OPEN);
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
combo = gtk_combo_box_text_new ();
g_signal_connect (combo, "changed",
G_CALLBACK (native_filter_changed), native);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
- gtk_container_add (GTK_CONTAINER (box), combo);
+ gtk_box_append (GTK_BOX (box), combo);
check_button = gtk_check_button_new_with_label ("Modal");
g_signal_connect (check_button, "toggled",
G_CALLBACK (native_modal_toggle), native);
- gtk_container_add (GTK_CONTAINER (box), check_button);
+ gtk_box_append (GTK_BOX (box), check_button);
check_button = gtk_check_button_new_with_label ("Multiple select");
g_signal_connect (check_button, "toggled",
G_CALLBACK (native_multi_select_toggle), native);
- gtk_container_add (GTK_CONTAINER (box), check_button);
+ gtk_box_append (GTK_BOX (box), check_button);
show_button = gtk_button_new_with_label ("Show");
hide_button = gtk_button_new_with_label ("Hide");
gtk_widget_set_sensitive (hide_button, FALSE);
- gtk_container_add (GTK_CONTAINER (box), show_button);
- gtk_container_add (GTK_CONTAINER (box), hide_button);
+ gtk_box_append (GTK_BOX (box), show_button);
+ gtk_box_append (GTK_BOX (box), hide_button);
/* connect signals */
g_signal_connect (native, "response",
gtk_get_minor_version ());
label = gtk_label_new (buffer);
- gtk_container_add (GTK_CONTAINER (box1), label);
+ gtk_box_append (GTK_BOX (box1), label);
gtk_widget_set_name (label, "testgtk-version-label");
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (box1), scrolled_window);
+ gtk_box_append (GTK_BOX (box1), scrolled_window);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_margin_top (box2, 10);
NULL);
else
gtk_widget_set_sensitive (button, FALSE);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
}
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box1), separator);
+ gtk_box_append (GTK_BOX (box1), separator);
+
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new_with_mnemonic ("_Close");
gtk_widget_set_margin_top (button, 10);
g_signal_connect (button, "clicked",
G_CALLBACK (do_exit),
window);
- gtk_container_add (GTK_CONTAINER (box1), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_window_set_default_widget (GTK_WINDOW (window), button);
gtk_widget_show (window);
gtk_widget_set_margin_top (header, 10);
gtk_widget_set_margin_bottom (header, 10);
label = gtk_label_new ("Label");
- gtk_container_add (GTK_CONTAINER (header), label);
+ gtk_box_append (GTK_BOX (header), label);
widget = gtk_level_bar_new ();
gtk_level_bar_set_value (GTK_LEVEL_BAR (widget), 0.4);
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (header), widget);
+ gtk_box_append (GTK_BOX (header), widget);
}
else
{
gtk_image_set_pixel_size (GTK_IMAGE (content), 512);
gtk_widget_set_vexpand (content, TRUE);
- gtk_container_add (GTK_CONTAINER (box), content);
+ gtk_box_append (GTK_BOX (box), content);
footer = gtk_action_bar_new ();
gtk_action_bar_set_center_widget (GTK_ACTION_BAR (footer), gtk_check_button_new_with_label ("Middle"));
button = gtk_button_new_with_label ("Fullscreen");
gtk_action_bar_pack_end (GTK_ACTION_BAR (footer), button);
g_signal_connect (button, "clicked", G_CALLBACK (toggle_fullscreen), window);
- gtk_container_add (GTK_CONTAINER (box), footer);
+ gtk_box_append (GTK_BOX (box), footer);
gtk_widget_show (window);
while (!done)
header = gtk_header_bar_new ();
gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), TRUE);
- gtk_container_add (GTK_CONTAINER (box), header);
+ gtk_box_append (GTK_BOX (box), header);
label = gtk_label_new ("This window has a headerbar inside the window and no titlebar");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_widget_set_vexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
gtk_widget_show (window);
}
"mi eu ipsum vestibulum in venenatis enim commodo. "
"Vivamus non malesuada ligula.");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
label = gtk_label_new ("This window has a headerbar inside an overlay, so the text is visible underneath it");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_widget_set_vexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
gtk_widget_show (window);
}
gtk_window_set_child (GTK_WINDOW (window), box);
revealer = gtk_revealer_new ();
- gtk_container_add (GTK_CONTAINER (box), revealer);
+ gtk_box_append (GTK_BOX (box), revealer);
header = gtk_header_bar_new ();
gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), TRUE);
label = gtk_label_new ("This window's headerbar can be shown and hidden with animation");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_widget_set_vexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER);
gtk_widget_set_margin_bottom (hbox, 12);
gtk_widget_set_margin_start (hbox, 12);
gtk_widget_set_margin_end (hbox, 12);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
toggle = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (toggle), TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), toggle);
+ gtk_box_append (GTK_BOX (hbox), toggle);
g_object_bind_property (toggle, "active",
revealer, "reveal-child",
G_BINDING_SYNC_CREATE);
label = gtk_label_new ("Show headerbar");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
gtk_widget_show (window);
}
gtk_window_handle_set_child (GTK_WINDOW_HANDLE (handle), box);
center_box = gtk_center_box_new ();
- gtk_container_add (GTK_CONTAINER (box), center_box);
+ gtk_box_append (GTK_BOX (box), center_box);
label = gtk_label_new ("Fake headerbar");
gtk_center_box_set_center_widget (GTK_CENTER_BOX (center_box), label);
label = gtk_label_new ("This window's titlebar is just a centerbox with a label and window controls.\nThe whole window is draggable.");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_widget_set_vexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (box), label);
+ gtk_box_append (GTK_BOX (box), label);
gtk_widget_show (window);
}
G_CALLBACK (buttons[i].cb),
app,
G_CONNECT_SWAPPED);
- gtk_container_add (GTK_CONTAINER (box), btn);
+ gtk_box_append (GTK_BOX (box), btn);
}
gtk_widget_show (window);
g_signal_connect (button, "clicked",
G_CALLBACK (test_clicked), &interfaces[i]);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
}
return window;
{
GtkWidget *box = gtk_event_controller_get_widget (controller);
- gtk_container_remove (GTK_CONTAINER (box), gtk_widget_get_first_child (box));
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("HOVER!"));
+ gtk_box_remove (GTK_BOX (box), gtk_widget_get_first_child (box));
+ gtk_box_append (GTK_BOX (box), gtk_label_new ("HOVER!"));
}
static void
{
GtkWidget *box = gtk_event_controller_get_widget (controller);
- gtk_container_remove (GTK_CONTAINER (box), gtk_widget_get_first_child (box));
- gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("start-here"));
+ gtk_box_remove (GTK_BOX (box), gtk_widget_get_first_child (box));
+ gtk_box_append (GTK_BOX (box), gtk_image_new_from_icon_name ("start-here"));
}
static void
g_signal_connect (controller, "leave", G_CALLBACK (leave1_cb), NULL);
gtk_widget_add_controller (box, controller);
- gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("start-here"));
+ gtk_box_append (GTK_BOX (box), gtk_image_new_from_icon_name ("start-here"));
gtk_widget_show (win);
g_signal_connect (controller, "leave", G_CALLBACK (leave2_cb), NULL);
gtk_widget_add_controller (box, controller);
- gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("start-here"));
- gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("HOVER!"));
+ gtk_box_append (GTK_BOX (box), gtk_image_new_from_icon_name ("start-here"));
+ gtk_box_append (GTK_BOX (box), gtk_label_new ("HOVER!"));
gtk_widget_hide (gtk_widget_get_last_child (box));
gtk_widget_show (win);
g_signal_connect (views.view1, "notify::has-focus", G_CALLBACK (focus_changed), &views);
g_signal_connect (views.view2, "notify::has-focus", G_CALLBACK (focus_changed), &views);
- gtk_container_add (GTK_CONTAINER (vbox), views.header1);
- gtk_container_add (GTK_CONTAINER (vbox), views.view1);
- gtk_container_add (GTK_CONTAINER (vbox), views.header2);
- gtk_container_add (GTK_CONTAINER (vbox), views.view2);
+ gtk_box_append (GTK_BOX (vbox), views.header1);
+ gtk_box_append (GTK_BOX (vbox), views.view1);
+ gtk_box_append (GTK_BOX (vbox), views.header2);
+ gtk_box_append (GTK_BOX (vbox), views.view2);
gtk_widget_show (window);
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_vexpand (paned, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), paned);
+ gtk_box_append (GTK_BOX (vbox), paned);
icon_list = gtk_icon_view_new ();
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_list), GTK_SELECTION_MULTIPLE);
bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_halign (bbox, GTK_ALIGN_START);
- gtk_container_add (GTK_CONTAINER (vbox), bbox);
+ gtk_box_append (GTK_BOX (vbox), bbox);
button = gtk_button_new_with_label ("Add some");
g_signal_connect (button, "clicked", G_CALLBACK (add_some), icon_list);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
button = gtk_button_new_with_label ("Add many");
g_signal_connect (button, "clicked", G_CALLBACK (add_many), icon_list);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
button = gtk_button_new_with_label ("Add large");
g_signal_connect (button, "clicked", G_CALLBACK (add_large), icon_list);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
button = gtk_button_new_with_label ("Remove selected");
g_signal_connect (button, "clicked", G_CALLBACK (foreach_selected_remove), icon_list);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
button = gtk_button_new_with_label ("Swap");
g_signal_connect (button, "clicked", G_CALLBACK (swap_rows), icon_list);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_halign (bbox, GTK_ALIGN_START);
- gtk_container_add (GTK_CONTAINER (vbox), bbox);
+ gtk_box_append (GTK_BOX (vbox), bbox);
button = gtk_button_new_with_label ("Select all");
g_signal_connect (button, "clicked", G_CALLBACK (select_all), icon_list);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
button = gtk_button_new_with_label ("Unselect all");
g_signal_connect (button, "clicked", G_CALLBACK (unselect_all), icon_list);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
button = gtk_button_new_with_label ("Select nonexisting");
g_signal_connect (button, "clicked", G_CALLBACK (select_nonexisting), icon_list);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
icon_list = gtk_icon_view_new ();
g_object_bind_property (widget, "active",
info_bar, "visible",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
widget = gtk_toggle_button_new_with_label ("Toggle :revealed");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
g_object_bind_property (widget, "active",
info_bar, "revealed",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
widget = gtk_toggle_button_new_with_label ("Toggle :show-close-button");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
g_object_bind_property (widget, "active",
info_bar, "show-close-button",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (widget),
g_object_bind_property (widget, "active",
info_bar, "message-type",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
- gtk_container_add (GTK_CONTAINER (box), widget);
+ gtk_box_append (GTK_BOX (box), widget);
- gtk_container_add (GTK_CONTAINER (box), info_bar);
+ gtk_box_append (GTK_BOX (box), info_bar);
widget = gtk_button_new_with_label ("Un-reveal");
gtk_info_bar_add_action_widget (GTK_INFO_BAR (info_bar), widget,
text_view = gtk_text_view_new ();
gtk_widget_set_hexpand (text_view, TRUE);
gtk_widget_set_vexpand (text_view, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), text_view);
+ gtk_box_append (GTK_BOX (vbox), text_view);
button = gtk_check_button_new_with_label ("Inhibit system keyboard shorcuts");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (on_button_toggle), surface);
gtk_widget_set_margin_bottom (box, 20);
bar = create_level_bar ();
gtk_window_set_child (GTK_WINDOW (window), box);
- gtk_container_add (GTK_CONTAINER (box), bar);
+ gtk_box_append (GTK_BOX (box), bar);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (box), box2);
- gtk_container_add (GTK_CONTAINER (box2), gtk_label_new ("Discrete"));
+ gtk_box_append (GTK_BOX (box), box2);
+ gtk_box_append (GTK_BOX (box2), gtk_label_new ("Discrete"));
sw = gtk_switch_new ();
- gtk_container_add (GTK_CONTAINER (box2), sw);
+ gtk_box_append (GTK_BOX (box2), sw);
g_signal_connect (sw, "notify::active", G_CALLBACK (toggle), bar);
gtk_widget_show (window);
update_header_cb (Row *row, Row *before, gpointer data)
{
GtkWidget *hbox, *l, *b;
- GList *children;
if (before == NULL ||
(row->label != NULL &&
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
l = gtk_label_new ("Header");
- gtk_container_add (GTK_CONTAINER (hbox), l);
+ gtk_box_append (GTK_BOX (hbox), l);
b = gtk_button_new_with_label ("button");
- gtk_container_add (GTK_CONTAINER (hbox), b);
+ gtk_box_append (GTK_BOX (hbox), b);
gtk_list_box_row_set_header (GTK_LIST_BOX_ROW (row), hbox);
}
hbox = gtk_list_box_row_get_header(GTK_LIST_BOX_ROW (row));
- children = gtk_container_get_children (GTK_CONTAINER (hbox));
- l = children->data;
- g_list_free (children);
+ l = gtk_widget_get_first_child (hbox);
gtk_label_set_text (GTK_LABEL (l), g_strdup_printf ("Header %d", row->sort_id));
}
else
list = gtk_list_box_new ();
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo),
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo),
"GTK_SELECTION_BROWSE");
g_signal_connect (combo, "changed", G_CALLBACK (selection_mode_changed), list);
- gtk_container_add (GTK_CONTAINER (vbox), combo);
+ gtk_box_append (GTK_BOX (vbox), combo);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), gtk_list_box_get_selection_mode (GTK_LIST_BOX (list)));
check = gtk_check_button_new_with_label ("single click mode");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), gtk_list_box_get_activate_on_single_click (GTK_LIST_BOX (list)));
g_signal_connect (check, "toggled", G_CALLBACK (single_click_clicked), list);
- gtk_container_add (GTK_CONTAINER (vbox), check);
+ gtk_box_append (GTK_BOX (vbox), check);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled), list);
- gtk_container_add (GTK_CONTAINER (hbox), scrolled);
+ gtk_box_append (GTK_BOX (hbox), scrolled);
g_signal_connect (list, "row-activated", G_CALLBACK (row_activated_cb), NULL);
g_signal_connect (list, "row-selected", G_CALLBACK (row_selected_cb), NULL);
row_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
row_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
l = gtk_label_new ("da box for da man");
- gtk_container_add (GTK_CONTAINER (row_hbox), l);
+ gtk_box_append (GTK_BOX (row_hbox), l);
check = gtk_check_button_new ();
- gtk_container_add (GTK_CONTAINER (row_hbox), check);
+ gtk_box_append (GTK_BOX (row_hbox), check);
button = gtk_button_new_with_label ("ya!");
- gtk_container_add (GTK_CONTAINER (row_hbox), button);
- gtk_container_add (GTK_CONTAINER (row_vbox), row_hbox);
+ gtk_box_append (GTK_BOX (row_hbox), button);
+ gtk_box_append (GTK_BOX (row_vbox), row_hbox);
check = gtk_check_button_new ();
- gtk_container_add (GTK_CONTAINER (row_vbox), check);
+ gtk_box_append (GTK_BOX (row_vbox), check);
gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), row_vbox);
gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
button = gtk_button_new_with_label ("sort");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (sort_clicked_cb), list);
button = gtk_button_new_with_label ("reverse");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (reverse_sort_clicked_cb), list);
button = gtk_button_new_with_label ("change");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (change_clicked_cb), row3);
button = gtk_button_new_with_label ("filter");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (filter_clicked_cb), list);
button = gtk_button_new_with_label ("unfilter");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (unfilter_clicked_cb), list);
button = gtk_button_new_with_label ("add");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (add_clicked_cb), list);
button = gtk_button_new_with_label ("separate");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (separate_clicked_cb), list);
button = gtk_button_new_with_label ("unseparate");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (unseparate_clicked_cb), list);
button = gtk_button_new_with_label ("visibility");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (visibility_clicked_cb), row3);
gtk_widget_show (window);
revealer = gtk_revealer_new ();
gtk_revealer_set_reveal_child (GTK_REVEALER (revealer), TRUE);
g_object_ref (child);
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (child)), child);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (child)), child);
gtk_revealer_set_child (GTK_REVEALER (revealer), child);
g_object_unref (child);
- gtk_container_add (GTK_CONTAINER (row), revealer);
+ gtk_box_append (GTK_BOX (row), revealer);
g_signal_connect (revealer, "notify::child-revealed",
G_CALLBACK (row_unrevealed), NULL);
gtk_revealer_set_reveal_child (GTK_REVEALER (revealer), FALSE);
child = gtk_revealer_get_child (GTK_REVEALER (revealer));
g_object_ref (child);
gtk_revealer_set_child (GTK_REVEALER (revealer), NULL);
+
gtk_widget_unparent (GTK_WIDGET (revealer));
- gtk_container_add (GTK_CONTAINER (row), child);
+ gtk_box_append (GTK_BOX (row), child);
g_object_unref (child);
}
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
label = gtk_label_new (text);
- gtk_container_add (GTK_CONTAINER (row), label);
+ gtk_box_append (GTK_BOX (row), label);
button = gtk_button_new_with_label ("x");
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_halign (button, GTK_ALIGN_END);
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (row), button);
+ gtk_box_append (GTK_BOX (row), button);
g_signal_connect (button, "clicked", G_CALLBACK (remove_this_row), row);
button = gtk_button_new_with_label ("+");
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (row), button);
+ gtk_box_append (GTK_BOX (row), button);
g_signal_connect (button, "clicked", G_CALLBACK (add_row_below), row);
return row;
return FALSE;
g_object_ref (source);
- gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (source)), source);
+ gtk_box_remove (GTK_BOX (gtk_widget_get_parent (source)), source);
gtk_list_box_insert (GTK_LIST_BOX (gtk_widget_get_parent (target)), source, pos);
g_object_unref (source);
label = gtk_label_new (text);
gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);
gtk_widget_set_hexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (box), label);
- gtk_container_add (GTK_CONTAINER (box), image);
+ gtk_box_append (GTK_BOX (box), label);
+ gtk_box_append (GTK_BOX (box), image);
source = gtk_drag_source_new ();
gtk_drag_source_set_actions (source, GDK_ACTION_MOVE);
gtk_widget_set_margin_end (vbox, 12);
gtk_widget_set_margin_top (vbox, 12);
gtk_widget_set_margin_bottom (vbox, 12);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
list = gtk_list_box_new ();
gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_hexpand (sw, TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
- gtk_container_add (GTK_CONTAINER (hbox), sw);
+ gtk_box_append (GTK_BOX (hbox), sw);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), list);
button = gtk_check_button_new_with_label ("Activate on single click");
g_object_bind_property (list, "activate-on-single-click",
button, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "None");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Browse");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Multiple");
g_signal_connect (combo, "changed", G_CALLBACK (selection_mode_changed), list);
- gtk_container_add (GTK_CONTAINER (vbox), combo);
+ gtk_box_append (GTK_BOX (vbox), combo);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), gtk_list_box_get_selection_mode (GTK_LIST_BOX (list)));
for (i = 0; i < 20; i++)
row_content = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
label = gtk_label_new (text);
- gtk_container_add (GTK_CONTAINER (row_content), label);
+ gtk_box_append (GTK_BOX (row_content), label);
return row_content;
}
gtk_window_set_child (GTK_WINDOW (window), box);
allowed_button = gtk_check_button_new_with_label ("Allowed");
- gtk_container_add (GTK_CONTAINER (box), allowed_button);
+ gtk_box_append (GTK_BOX (box), allowed_button);
can_acquire_button = gtk_check_button_new_with_label ("Can acquire");
- gtk_container_add (GTK_CONTAINER (box), can_acquire_button);
+ gtk_box_append (GTK_BOX (box), can_acquire_button);
can_release_button = gtk_check_button_new_with_label ("Can release");
- gtk_container_add (GTK_CONTAINER (box), can_release_button);
+ gtk_box_append (GTK_BOX (box), can_release_button);
success_button = gtk_check_button_new_with_label ("Will succeed");
- gtk_container_add (GTK_CONTAINER (box), success_button);
+ gtk_box_append (GTK_BOX (box), success_button);
update = gtk_button_new_with_label ("Update");
- gtk_container_add (GTK_CONTAINER (box), update);
+ gtk_box_append (GTK_BOX (box), update);
g_signal_connect (permission, "notify",
G_CALLBACK (permission_changed), NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
content = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (content), gtk_check_button_new_with_label ("Control 1"));
- gtk_container_add (GTK_CONTAINER (content), gtk_check_button_new_with_label ("Control 2"));
+ gtk_box_append (GTK_BOX (content), gtk_check_button_new_with_label ("Control 1"));
+ gtk_box_append (GTK_BOX (content), gtk_check_button_new_with_label ("Control 2"));
gtk_widget_set_sensitive (content, FALSE);
- gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), content);
- gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), button);
+ gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), content);
+ gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), button);
gtk_widget_show (window);
gtk_widget_show (dialog);
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
- gtk_container_add (GTK_CONTAINER (box), grid);
+ gtk_box_append (GTK_BOX (box), grid);
label = gtk_label_new ("Inhibitor");
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), button, 2, 6, 1, 1);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
- gtk_container_add (GTK_CONTAINER (box), separator);
+ gtk_box_append (GTK_BOX (box), separator);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
--- /dev/null
+#include <gtk/gtk.h>
+#include "gtk/gtkmodelbuttonprivate.h"
+
+static void
+on_action_beep (GSimpleAction *action,
+ GVariant *parameter,
+ void *user_data)
+{
+ GdkDisplay *display = gdk_display_get_default ();
+ gdk_display_beep (display);
+}
+
+static void
+on_application_activate (GApplication *gapplication,
+ void *user_data)
+{
+ GtkApplication *application = GTK_APPLICATION (gapplication);
+ GtkCssProvider *css_provider = gtk_css_provider_new ();
+ GdkDisplay *display = gdk_display_get_default ();
+
+ GSimpleAction *action;
+ GtkWidget *box;
+ GIcon *gicon;
+ GtkWidget *model_button;
+ GtkWidget *widget;
+
+ gtk_css_provider_load_from_data (css_provider,
+ "window > box { padding: 0.5em; }"
+ "window > box > * { margin: 0.5em; }"
+ /* :iconic == FALSE */
+ "modelbutton > check { background: red; }"
+ "modelbutton > radio { background: green; }"
+ "modelbutton > arrow { background: blue; }"
+ /* :iconic == TRUE */
+ "button.model { background: yellow; }"
+ , -1);
+ g_assert (GDK_IS_DISPLAY (display));
+ gtk_style_context_add_provider_for_display (display,
+ GTK_STYLE_PROVIDER (css_provider),
+ GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+ action = g_simple_action_new ("beep", NULL);
+ g_signal_connect (action, "activate", G_CALLBACK (on_action_beep), NULL);
+ g_action_map_add_action (G_ACTION_MAP (application), G_ACTION (action));
+
+ box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+
+ gicon = g_themed_icon_new ("face-smile");
+
+ model_button = g_object_new (g_type_from_name ("GtkModelButton"),
+ "action-name", "app.beep",
+ "text", "It’s-a-me! ModelButton",
+ "icon", gicon,
+ NULL);
+ gtk_box_append (GTK_BOX (box), model_button);
+
+ g_object_unref (gicon);
+
+ widget = gtk_combo_box_text_new ();
+ gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (widget),
+ NULL, "GTK_BUTTON_ROLE_NORMAL");
+ gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (widget),
+ NULL, "GTK_BUTTON_ROLE_CHECK");
+ gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (widget),
+ NULL, "GTK_BUTTON_ROLE_RADIO");
+ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
+ g_object_bind_property (widget, "active",
+ model_button, "role",
+ G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
+ gtk_box_append (GTK_BOX (box), widget);
+
+ widget = gtk_toggle_button_new_with_label (":iconic");
+ g_object_bind_property (widget, "active",
+ model_button, "iconic",
+ G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
+ gtk_box_append (GTK_BOX (box), widget);
+
+ widget = gtk_window_new ();
+ gtk_box_append (GTK_BOX (widget), box);
+ gtk_widget_show (widget);
+ gtk_application_add_window (GTK_APPLICATION (application), GTK_WINDOW (widget));
+}
+
+int
+main (int argc,
+ char *argv[])
+{
+ GtkApplication *application = gtk_application_new ("org.gtk.test.modelbutton",
+ G_APPLICATION_FLAGS_NONE);
+ int result;
+
+ g_signal_connect (application, "activate",
+ G_CALLBACK (on_application_activate), NULL);
+
+ result = g_application_run (G_APPLICATION (application), argc, argv);
+ g_object_unref (application);
+ return result;
+}
tab_label = gtk_notebook_get_tab_label (GTK_NOTEBOOK (parent), child);
g_print ("Removing tab: %s\n", gtk_label_get_text (GTK_LABEL (tab_label)));
- gtk_container_remove (GTK_CONTAINER (parent), child);
+ gtk_box_remove (GTK_BOX (parent), child);
return G_SOURCE_REMOVE;
}
/* Use GtkListBox since it bubbles up motion notify event, which can
* experience more issues than GtkBox. */
page = gtk_list_box_new ();
- gtk_container_add (GTK_CONTAINER (page), button);
+ gtk_box_append (GTK_BOX (page), button);
button = gtk_button_new_with_label ("row 2");
- gtk_container_add (GTK_CONTAINER (page), button);
+ gtk_box_append (GTK_BOX (page), button);
button = gtk_button_new_with_label ("third row");
- gtk_container_add (GTK_CONTAINER (page), button);
+ gtk_box_append (GTK_BOX (page), button);
title = gtk_label_new (*labels);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
button = gtk_toggle_button_new_with_label ("Horizontal");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
/* GtkBox */
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
orientables = g_list_prepend (orientables, box);
- gtk_container_add (GTK_CONTAINER (vbox), box);
- gtk_container_add (GTK_CONTAINER (box),
+ gtk_box_append (GTK_BOX (vbox), box);
+ gtk_box_append (GTK_BOX (box),
gtk_button_new_with_label ("GtkBox 1"));
- gtk_container_add (GTK_CONTAINER (box),
+ gtk_box_append (GTK_BOX (box),
gtk_button_new_with_label ("GtkBox 2"));
- gtk_container_add (GTK_CONTAINER (box),
+ gtk_box_append (GTK_BOX (box),
gtk_button_new_with_label ("GtkBox 3"));
g_signal_connect (button, "toggled",
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "one");
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "two");
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "three");
gtk_widget_set_opacity (w, 0.7);
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "four");
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "five");
- gtk_container_add (GTK_CONTAINER (top), w);
+ gtk_box_append (GTK_BOX (top), w);
/* Bottom */
w = gtk_button_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_add_css_class (w, "b1");
- gtk_container_add (GTK_CONTAINER (bottom), w);
+ gtk_box_append (GTK_BOX (bottom), w);
/*w = gtk_button_new ();*/
/*gtk_widget_set_valign (w, GTK_ALIGN_CENTER);*/
/*gtk_widget_add_css_class (w, "b2");*/
- /*gtk_container_add (GTK_CONTAINER (bottom), w);*/
+ /*gtk_box_append (GTK_BOX (bottom), w);*/
/*w = gtk_button_new ();*/
/*gtk_widget_set_valign (w, GTK_ALIGN_CENTER);*/
/*gtk_widget_add_css_class (w, "b3");*/
- /*gtk_container_add (GTK_CONTAINER (bottom), w);*/
+ /*gtk_box_append (GTK_BOX (bottom), w);*/
/*w = gtk_button_new ();*/
/*gtk_widget_set_valign (w, GTK_ALIGN_CENTER);*/
/*gtk_widget_add_css_class (w, "b4");*/
- /*gtk_container_add (GTK_CONTAINER (bottom), w);*/
+ /*gtk_box_append (GTK_BOX (bottom), w);*/
- gtk_container_add (GTK_CONTAINER (box), top);
- gtk_container_add (GTK_CONTAINER (box), bottom);
+ gtk_box_append (GTK_BOX (box), top);
+ gtk_box_append (GTK_BOX (box), bottom);
gtk_window_set_child (GTK_WINDOW (window), box);
g_signal_connect (window, "destroy", G_CALLBACK (quit_cb), &done);
gtk_widget_show (window);
check2 = gtk_check_button_new_with_label ("Show overlay");
g_object_bind_property (child, "visible", check2, "active", G_BINDING_BIDIRECTIONAL);
- gtk_container_add (GTK_CONTAINER (main_child), label);
+ gtk_box_append (GTK_BOX (main_child), label);
gtk_overlay_set_child (GTK_OVERLAY (overlay), main_child);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
gtk_grid_attach (GTK_GRID (grid), overlay, 1, 0, 1, 3);
"But the entry does");
gtk_widget_set_margin_top (label, 8);
gtk_widget_set_margin_bottom (label, 8);
- gtk_container_add (GTK_CONTAINER (vbox), label);
+ gtk_box_append (GTK_BOX (vbox), label);
entry = gtk_entry_new ();
gtk_widget_set_margin_top (entry, 8);
gtk_widget_set_margin_bottom (entry, 8);
- gtk_container_add (GTK_CONTAINER (vbox), entry);
+ gtk_box_append (GTK_BOX (vbox), entry);
gtk_window_set_child (GTK_WINDOW (win), overlay);
label = gtk_label_new ("Main child");
gtk_widget_set_halign (label, GTK_ALIGN_CENTER);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (main_child), label);
+ gtk_box_append (GTK_BOX (main_child), label);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
NULL);
gtk_widget_set_halign (combo_box, GTK_ALIGN_START);
- gtk_container_add (GTK_CONTAINER (vbox), combo_box);
+ gtk_box_append (GTK_BOX (vbox), combo_box);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Overall Alpha:");
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
adjustment = gtk_adjustment_new (overall_alpha, 0, 255, 1, 10, 0);
g_signal_connect (adjustment, "value_changed",
hscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
gtk_scale_set_digits (GTK_SCALE (hscale), 0);
gtk_widget_set_hexpand (hscale, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), hscale);
+ gtk_box_append (GTK_BOX (hbox), hscale);
/* Compute the size without the drawing area, so we know how big to make the default size */
gtk_widget_get_preferred_size ( (vbox),
darea = gtk_drawing_area_new ();
gtk_widget_set_hexpand (darea, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), darea);
+ gtk_box_append (GTK_BOX (vbox), darea);
gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (darea), draw_func, NULL, NULL);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_menu_button_new ();
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button1 = gtk_menu_button_new ();
- gtk_container_add (GTK_CONTAINER (box), button1);
+ gtk_box_append (GTK_BOX (box), button1);
button2 = gtk_menu_button_new ();
- gtk_container_add (GTK_CONTAINER (box), button2);
+ gtk_box_append (GTK_BOX (box), button2);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), model);
popover = GTK_WIDGET (gtk_menu_button_get_popover (GTK_MENU_BUTTON (button)));
revealer = gtk_revealer_new ();
gtk_revealer_set_transition_type (GTK_REVEALER (revealer),
GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT);
- gtk_container_add (GTK_CONTAINER (hbox), revealer);
+ gtk_box_append (GTK_BOX (hbox), revealer);
sidebar = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_size_request (sidebar, 150, -1);
"halign", GTK_ALIGN_CENTER,
"valign", GTK_ALIGN_CENTER,
NULL);
- gtk_container_add (GTK_CONTAINER (hbox), img);
+ gtk_box_append (GTK_BOX (hbox), img);
g_object_bind_property (sidebar_toggle, "active",
revealer, "reveal-child",
flipbox = box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_widget_set_hexpand (flipbox, TRUE);
gtk_widget_set_vexpand (flipbox, TRUE);
- gtk_container_add (GTK_CONTAINER (box1), box);
+ gtk_box_append (GTK_BOX (box1), box);
gtk_window_set_child (GTK_WINDOW (window), box1);
frame = gtk_frame_new ("No marks");
scales = g_slist_prepend (scales, scale);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_frame_set_child (GTK_FRAME (frame), scale);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
frame = gtk_frame_new ("With fill level");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
gtk_range_set_show_fill_level (GTK_RANGE (scale), TRUE);
gtk_range_set_fill_level (GTK_RANGE (scale), 50);
gtk_frame_set_child (GTK_FRAME (frame), scale);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
frame = gtk_frame_new ("Simple marks");
extra_scale = scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_BOTTOM, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_BOTTOM, NULL);
gtk_frame_set_child (GTK_FRAME (frame), scale);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
frame = gtk_frame_new ("Simple marks up");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_TOP, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_TOP, NULL);
gtk_frame_set_child (GTK_FRAME (frame), scale);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
frame = gtk_frame_new ("Labeled marks");
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_BOTTOM, labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_BOTTOM, labels[2]);
gtk_frame_set_child (GTK_FRAME (frame), scale);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
frame = gtk_frame_new ("Some labels");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_TOP, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_TOP, labels[2]);
gtk_frame_set_child (GTK_FRAME (frame), scale);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
frame = gtk_frame_new ("Above and below");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[2], GTK_POS_BOTTOM, bath_labels[2]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[3], GTK_POS_TOP, bath_labels[3]);
gtk_frame_set_child (GTK_FRAME (frame), scale);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
frame = gtk_frame_new ("Positions");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[2], GTK_POS_TOP, pos_labels[2]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[3], GTK_POS_BOTTOM, pos_labels[3]);
gtk_frame_set_child (GTK_FRAME (frame), scale);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
- gtk_container_add (GTK_CONTAINER (box1), box2);
+ gtk_box_append (GTK_BOX (box1), box2);
button = gtk_button_new_with_label ("Flip");
g_signal_connect (button, "clicked", G_CALLBACK (flip), NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_button_new_with_label ("Invert");
g_signal_connect (button, "clicked", G_CALLBACK (invert), NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_toggle_button_new_with_label ("Trough");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (button, "toggled", G_CALLBACK (trough), NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_widget_show (window);
button = gtk_toggle_button_new_with_label ("Extra");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
g_signal_connect (button, "toggled", G_CALLBACK (extra), NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_widget_show (window);
while (!done)
gtk_widget_set_margin_bottom (popup, 40);
label = gtk_label_new ("Getting more rows...");
spinner = gtk_spinner_new ();
- gtk_container_add (GTK_CONTAINER (popup), label);
- gtk_container_add (GTK_CONTAINER (popup), spinner);
+ gtk_box_append (GTK_BOX (popup), label);
+ gtk_box_append (GTK_BOX (popup), spinner);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), popup);
gtk_widget_hide (popup);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_window_set_child (GTK_WINDOW (window), hbox);
- gtk_container_add (GTK_CONTAINER (hbox), vbox);
+ gtk_box_append (GTK_BOX (hbox), vbox);
frame = gtk_frame_new ("Scrolled Window");
gtk_widget_set_hexpand (frame, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), frame);
+ gtk_box_append (GTK_BOX (hbox), frame);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_expander_set_child (GTK_EXPANDER (expander), cntl);
- gtk_container_add (GTK_CONTAINER (vbox), expander);
+ gtk_box_append (GTK_BOX (vbox), expander);
/* Add Horizontal policy control here */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
widget = gtk_label_new ("hscroll-policy");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Minimum");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (cntl), hbox);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (cntl), hbox);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (horizontal_policy_changed), viewport);
widget = gtk_label_new ("vscroll-policy");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Minimum");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (cntl), hbox);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (cntl), hbox);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (vertical_policy_changed), viewport);
widget = gtk_label_new ("min-content-width");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_spin_button_new_with_range (100.0, 1000.0, 10.0);
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (cntl), hbox);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (cntl), hbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (content_width_changed), swindow);
widget = gtk_label_new ("min-content-height");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_spin_button_new_with_range (100.0, 1000.0, 10.0);
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (cntl), hbox);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (cntl), hbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (content_height_changed), swindow);
/* Add Kinetic scrolling control here */
widget = gtk_check_button_new_with_label ("Kinetic scrolling");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (cntl), widget);
+ gtk_box_append (GTK_BOX (cntl), widget);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (kinetic_scrolling_changed), swindow);
widget = gtk_menu_button_new ();
gtk_menu_button_set_popover (GTK_MENU_BUTTON (widget), popover);
gtk_menu_button_set_label (GTK_MENU_BUTTON (widget), "Popover");
- gtk_container_add (GTK_CONTAINER (cntl), widget);
+ gtk_box_append (GTK_BOX (cntl), widget);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_popover_set_child (GTK_POPOVER (popover), vbox);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (vbox), swindow);
+ gtk_box_append (GTK_BOX (vbox), swindow);
/* Listbox */
listbox = gtk_list_box_new ();
widget = gtk_label_new ("min-content-width");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_spin_button_new_with_range (0.0, 150.0, 10.0);
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)),
"value",
widget = gtk_label_new ("min-content-height");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_spin_button_new_with_range (0.0, 150.0, 10.0);
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (vbox), hbox);
g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)),
"value",
widget = gtk_label_new ("max-content-width");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_spin_button_new_with_range (250.0, 1000.0, 10.0);
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)),
"value",
widget = gtk_label_new ("max-content-height");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
widget = gtk_spin_button_new_with_range (250.0, 1000.0, 10.0);
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (vbox), hbox);
g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)),
"value",
widget = gtk_button_new_with_label ("Remove");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
+ gtk_box_append (GTK_BOX (hbox), widget);
g_signal_connect (widget, "clicked",
G_CALLBACK (remove_row), listbox);
widget = gtk_button_new_with_label ("Add");
gtk_widget_set_hexpand (widget, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), widget);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), widget);
+ gtk_box_append (GTK_BOX (vbox), hbox);
g_signal_connect (widget, "clicked",
G_CALLBACK (add_row), listbox);
gtk_widget_set_margin_bottom (row->check, 10);
gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), row->box);
- gtk_container_add (GTK_CONTAINER (row->box), row->revealer);
+ gtk_box_append (GTK_BOX (row->box), row->revealer);
gtk_revealer_set_child (GTK_REVEALER (row->revealer), row->check);
}
static void
selectable_row_add (SelectableRow *row, GtkWidget *child)
{
- gtk_container_add (GTK_CONTAINER (row->box), child);
+ gtk_box_append (GTK_BOX (row->box), child);
}
static void
gtk_window_set_child (GTK_WINDOW (window), box);
w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 15);
- gtk_container_add (GTK_CONTAINER (box), w);
- gtk_container_add (GTK_CONTAINER (w), gtk_entry_new ());
+ gtk_box_append (GTK_BOX (box), w);
+ gtk_box_append (GTK_BOX (w), gtk_entry_new ());
bu = gtk_button_new_with_label ("Bu");
- gtk_container_add (GTK_CONTAINER (w), bu);
+ gtk_box_append (GTK_BOX (w), bu);
c = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (c), TRUE);
gtk_widget_set_halign (c, GTK_ALIGN_CENTER);
gtk_widget_set_valign (c, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (box), c);
+ gtk_box_append (GTK_BOX (box), c);
g_signal_connect (bu, "clicked", G_CALLBACK (set_insensitive), w);
g_signal_connect (bu, "state-flags-changed", G_CALLBACK (state_flags_changed), NULL);
button = gtk_button_new_with_label ("Α");
g_signal_connect (button, "clicked", G_CALLBACK (enter), NULL);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
button = gtk_button_new_with_label ("Ω");
g_signal_connect (button, "clicked", G_CALLBACK (leave), NULL);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
gtk_window_present (GTK_WINDOW (window));
gtk_window_set_child (GTK_WINDOW (window), mainbox);
wrap_button = gtk_toggle_button_new_with_label ("Wrap");
- gtk_container_add (GTK_CONTAINER (mainbox), wrap_button);
+ gtk_box_append (GTK_BOX (mainbox), wrap_button);
for (max = 9; max <= 999999999; max = max * 10 + 9)
{
g_object_bind_property (wrap_button, "active", spin, "wrap", G_BINDING_SYNC_CREATE);
GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
- gtk_container_add (GTK_CONTAINER (hbox), spin);
- gtk_container_add (GTK_CONTAINER (mainbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), spin);
+ gtk_box_append (GTK_BOX (mainbox), hbox);
}
gtk_widget_show (window);
gtk_window_set_child (GTK_WINDOW (window), box);
switcher = gtk_stack_switcher_new ();
- gtk_container_add (GTK_CONTAINER (box), switcher);
+ gtk_box_append (GTK_BOX (box), switcher);
stack = gtk_stack_new ();
sidebar = gtk_stack_sidebar_new ();
gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
layout = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (layout), sidebar);
+ gtk_box_append (GTK_BOX (layout), sidebar);
gtk_widget_set_hexpand (stack, TRUE);
- gtk_container_add (GTK_CONTAINER (layout), stack);
+ gtk_box_append (GTK_BOX (layout), stack);
- gtk_container_add (GTK_CONTAINER (box), layout);
+ gtk_box_append (GTK_BOX (box), layout);
gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER (switcher), GTK_STACK (stack));
gtk_stack_add_titled (GTK_STACK (stack), w3, "3", "3");
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
button = gtk_button_new_with_label ("1");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked", (GCallback) set_visible_child, w1);
button = gtk_button_new_with_label ("2");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked", (GCallback) set_visible_child, w2);
button = gtk_button_new_with_label ("3");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked", (GCallback) set_visible_child, w3);
button = gtk_button_new_with_label ("1");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked", (GCallback) set_visible_child_name, (gpointer) "1");
button = gtk_button_new_with_label ("2");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked", (GCallback) set_visible_child_name, (gpointer) "2");
button = gtk_button_new_with_label ("3");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked", (GCallback) set_visible_child_name, (gpointer) "3");
button = gtk_check_button_new ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
gtk_stack_get_hhomogeneous (GTK_STACK (stack)));
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked", (GCallback) toggle_hhomogeneous, NULL);
button = gtk_check_button_new_with_label ("homogeneous");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
gtk_stack_get_vhomogeneous (GTK_STACK (stack)));
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked", (GCallback) toggle_vhomogeneous, NULL);
button = gtk_toggle_button_new_with_label ("Add icon");
g_signal_connect (button, "toggled", (GCallback) toggle_icon_name, NULL);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
combo = gtk_combo_box_text_new ();
class = g_type_class_ref (GTK_TYPE_STACK_TRANSITION_TYPE);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), class->values[i].value_nick);
g_type_class_unref (class);
- gtk_container_add (GTK_CONTAINER (hbox), combo);
+ gtk_box_append (GTK_BOX (hbox), combo);
g_signal_connect (combo, "changed", (GCallback) toggle_transitions, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (box), hbox);
+ gtk_box_append (GTK_BOX (box), hbox);
button = gtk_button_new_with_label ("<");
g_signal_connect (button, "clicked", (GCallback) on_back_button_clicked, stack);
g_signal_connect (stack, "notify::visible-child-name",
(GCallback)update_back_button_sensitivity, button);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
button = gtk_button_new_with_label (">");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
g_signal_connect (button, "clicked", (GCallback) on_forward_button_clicked, stack);
g_signal_connect (stack, "notify::visible-child-name",
(GCallback)update_forward_button_sensitivity, button);
sw = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (sw), is_on);
- gtk_container_add (GTK_CONTAINER (hbox), sw);
+ gtk_box_append (GTK_BOX (hbox), sw);
gtk_widget_set_sensitive (sw, is_sensitive);
label = gtk_label_new (is_on ? "Enabled" : "Disabled");
gtk_widget_set_hexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
g_object_bind_property_full (sw, "active",
label, "label",
sw = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (sw), is_on);
- gtk_container_add (GTK_CONTAINER (hbox), sw);
+ gtk_box_append (GTK_BOX (hbox), sw);
gtk_widget_set_sensitive (sw, is_sensitive);
g_signal_connect (sw, "state-set", G_CALLBACK (set_state), NULL);
spinner = gtk_spinner_new ();
- gtk_container_add (GTK_CONTAINER (hbox), spinner);
+ gtk_box_append (GTK_BOX (hbox), spinner);
gtk_widget_set_opacity (spinner, 0.0);
label = gtk_label_new (is_on ? "Enabled" : "Disabled");
gtk_widget_set_hexpand (label, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), label);
+ gtk_box_append (GTK_BOX (hbox), label);
g_object_bind_property_full (sw, "active",
label, "label",
NULL, NULL);
check = gtk_check_button_new ();
- gtk_container_add (GTK_CONTAINER (hbox), check);
+ gtk_box_append (GTK_BOX (hbox), check);
g_object_bind_property (sw, "state",
check, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
gtk_window_set_child (GTK_WINDOW (window), vbox);
hbox = make_switch (FALSE, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
hbox = make_switch (TRUE, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
hbox = make_switch (FALSE, FALSE);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
hbox = make_switch (TRUE, FALSE);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
hbox = make_delayed_switch (FALSE, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
while (!done)
g_main_context_iteration (NULL, TRUE);
gtk_widget_set_hexpand (sw, TRUE);
gtk_widget_set_vexpand (sw, TRUE);
gtk_window_set_child (GTK_WINDOW (window), box);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
tv = gtk_text_view_new ();
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), tv);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
g_object_set (box, "margin-start", 10, "margin-end", 10, NULL);
- gtk_container_add (GTK_CONTAINER (box), box2);
+ gtk_box_append (GTK_BOX (box), box2);
the_mark = gtk_text_mark_new ("my mark", TRUE);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
- gtk_container_add (GTK_CONTAINER (box), box2);
+ gtk_box_append (GTK_BOX (box), box2);
mark_check = gtk_check_button_new_with_label ("Mark");
g_signal_connect (mark_check, "notify::active", G_CALLBACK (update_mark_exists), NULL);
- gtk_container_add (GTK_CONTAINER (box2), mark_check);
+ gtk_box_append (GTK_BOX (box2), mark_check);
mark_visible = gtk_check_button_new_with_label ("Visible");
g_signal_connect (mark_visible, "notify::active", G_CALLBACK (update_mark_visible), NULL);
- gtk_container_add (GTK_CONTAINER (box2), mark_visible);
- gtk_container_add (GTK_CONTAINER (box2), gtk_label_new ("Position:"));
+ gtk_box_append (GTK_BOX (box2), mark_visible);
+ gtk_box_append (GTK_BOX (box2), gtk_label_new ("Position:"));
position_spin = gtk_spin_button_new_with_range (0, len, 1);
g_signal_connect (position_spin, "value-changed", G_CALLBACK (update_mark_position), NULL);
- gtk_container_add (GTK_CONTAINER (box2), position_spin);
+ gtk_box_append (GTK_BOX (box2), position_spin);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
g_object_set (box, "margin-start", 10, "margin-end", 10, NULL);
- gtk_container_add (GTK_CONTAINER (box), box2);
+ gtk_box_append (GTK_BOX (box), box2);
button = gtk_toggle_button_new_with_label ("Random marks");
g_signal_connect (button, "notify::active", G_CALLBACK (toggle_marks), NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
button = gtk_toggle_button_new_with_label ("Wandering cursor");
g_signal_connect (button, "notify::active", G_CALLBACK (toggle_cursor), NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
gtk_widget_show (window);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_window_set_child (GTK_WINDOW (window), box);
frame = gtk_frame_new (NULL);
- gtk_container_add (GTK_CONTAINER (box), frame);
+ gtk_box_append (GTK_BOX (box), frame);
view = gtk_text_view_new ();
gtk_widget_set_vexpand (view, TRUE);
- gtk_container_add (GTK_CONTAINER (box), view);
+ gtk_box_append (GTK_BOX (box), view);
box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_margin_start (box3, 10);
gtk_widget_set_margin_end (box3, 10);
gtk_widget_add_css_class (box3, GTK_STYLE_CLASS_LINKED);
button = gtk_button_new_from_icon_name ("document-new-symbolic");
- gtk_container_add (GTK_CONTAINER (box3), button);
+ gtk_box_append (GTK_BOX (box3), button);
button = gtk_button_new_from_icon_name ("document-open-symbolic");
- gtk_container_add (GTK_CONTAINER (box3), button);
+ gtk_box_append (GTK_BOX (box3), button);
button = gtk_button_new_from_icon_name ("document-save-symbolic");
- gtk_container_add (GTK_CONTAINER (box3), button);
+ gtk_box_append (GTK_BOX (box3), button);
gtk_frame_set_child (GTK_FRAME (frame), box3);
gtk_widget_set_margin_top (tooltip, 20);
gtk_widget_set_margin_bottom (tooltip, 20);
gtk_widget_set_halign (tooltip, GTK_ALIGN_CENTER);
- gtk_container_add (GTK_CONTAINER (box), tooltip);
+ gtk_box_append (GTK_BOX (box), tooltip);
/* A check button using the tooltip-markup property */
button = gtk_check_button_new_with_label ("This one uses the tooltip-markup property");
gtk_widget_set_tooltip_text (button, "Hello, I am a static tooltip.");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
text = gtk_widget_get_tooltip_text (button);
markup = gtk_widget_get_tooltip_markup (button);
g_object_set (button, "has-tooltip", TRUE, NULL);
g_signal_connect (button, "query-tooltip",
G_CALLBACK (query_tooltip_cb), NULL);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
/* A label */
button = gtk_label_new ("I am just a label");
gtk_label_set_selectable (GTK_LABEL (button), FALSE);
gtk_widget_set_tooltip_text (button, "Label & and tooltip");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
text = gtk_widget_get_tooltip_text (button);
markup = gtk_widget_get_tooltip_markup (button);
button = gtk_label_new ("I am a selectable label");
gtk_label_set_selectable (GTK_LABEL (button), TRUE);
gtk_widget_set_tooltip_markup (button, "<b>Another</b> Label tooltip");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
text = gtk_widget_get_tooltip_text (button);
markup = gtk_widget_get_tooltip_markup (button);
button = gtk_button_new_with_label ("This one is insensitive");
gtk_widget_set_sensitive (button, FALSE);
g_object_set (button, "tooltip-text", "Insensitive!", NULL);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
/* Testcases from Kris without a tree view don't exist. */
tree_view = gtk_tree_view_new_with_model (create_model ());
gtk_tree_view_column_set_clickable (column, TRUE);
g_object_set (gtk_tree_view_column_get_button (column), "tooltip-text", "Header", NULL);
- gtk_container_add (GTK_CONTAINER (box), tree_view);
+ gtk_box_append (GTK_BOX (box), tree_view);
/* And a text view for Matthias */
buffer = gtk_text_buffer_new (NULL);
g_signal_connect (text_view, "query-tooltip",
G_CALLBACK (query_tooltip_text_view_cb), tag);
- gtk_container_add (GTK_CONTAINER (box), text_view);
+ gtk_box_append (GTK_BOX (box), text_view);
/* Drawing area */
drawing_area = gtk_drawing_area_new ();
g_object_set (drawing_area, "has-tooltip", TRUE, NULL);
g_signal_connect (drawing_area, "query-tooltip",
G_CALLBACK (query_tooltip_drawing_area_cb), NULL);
- gtk_container_add (GTK_CONTAINER (box), drawing_area);
+ gtk_box_append (GTK_BOX (box), drawing_area);
button = gtk_menu_button_new ();
gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
gtk_menu_button_set_label (GTK_MENU_BUTTON (button), "Custom tooltip I");
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
popover = gtk_popover_new ();
gtk_menu_button_set_popover (GTK_MENU_BUTTON (button), popover);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
button = gtk_label_new ("Hidden here");
custom = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
- gtk_container_add (GTK_CONTAINER (custom), gtk_label_new ("See, custom"));
- gtk_container_add (GTK_CONTAINER (custom), g_object_new (GTK_TYPE_SPINNER, "spinning", TRUE, NULL));
+ gtk_box_append (GTK_BOX (custom), gtk_label_new ("See, custom"));
+ gtk_box_append (GTK_BOX (custom), g_object_new (GTK_TYPE_SPINNER, "spinning", TRUE, NULL));
g_object_ref_sink (custom);
g_object_set (button, "has-tooltip", TRUE, NULL);
- gtk_container_add (GTK_CONTAINER (box2), button);
+ gtk_box_append (GTK_BOX (box2), button);
g_signal_connect (button, "query-tooltip",
G_CALLBACK (query_tooltip_label_cb), custom);
button = gtk_label_new ("Custom tooltip II");
custom = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
- gtk_container_add (GTK_CONTAINER (custom), gtk_label_new ("See, custom too"));
- gtk_container_add (GTK_CONTAINER (custom), g_object_new (GTK_TYPE_SPINNER, "spinning", TRUE, NULL));
+ gtk_box_append (GTK_BOX (custom), gtk_label_new ("See, custom too"));
+ gtk_box_append (GTK_BOX (custom), g_object_new (GTK_TYPE_SPINNER, "spinning", TRUE, NULL));
g_object_ref_sink (custom);
g_object_set (button, "has-tooltip", TRUE, NULL);
g_signal_connect (button, "query-tooltip",
G_CALLBACK (query_tooltip_label_cb), custom);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
/* Done! */
gtk_widget_show (window);
gtk_window_set_child (GTK_WINDOW (window), vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
/* Left Pane */
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_append_column (GTK_TREE_VIEW (left_tree_view), column);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
- gtk_container_add (GTK_CONTAINER (hbox), swindow);
+ gtk_box_append (GTK_BOX (hbox), swindow);
/* Middle Pane */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (hbox), vbox2);
+ gtk_box_append (GTK_BOX (hbox), vbox2);
bbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox2), bbox);
+ gtk_box_append (GTK_BOX (vbox2), bbox);
button = gtk_button_new_with_mnemonic ("<< (_Q)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), top_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (top_right_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
button = gtk_button_new_with_mnemonic (">> (_W)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), top_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
bbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox2), bbox);
+ gtk_box_append (GTK_BOX (vbox2), bbox);
button = gtk_button_new_with_mnemonic ("<< (_E)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), bottom_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (bottom_right_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
button = gtk_button_new_with_mnemonic (">> (_R)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), bottom_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
- gtk_container_add (GTK_CONTAINER (bbox), button);
+ gtk_box_append (GTK_BOX (bbox), button);
/* Right Pane */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (hbox), vbox2);
+ gtk_box_append (GTK_BOX (hbox), vbox2);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_append_column (GTK_TREE_VIEW (top_right_tree_view), column);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (swindow), top_right_tree_view);
- gtk_container_add (GTK_CONTAINER (vbox2), swindow);
+ gtk_box_append (GTK_BOX (vbox2), swindow);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (bottom_right_tree_view), column);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (swindow), bottom_right_tree_view);
- gtk_container_add (GTK_CONTAINER (vbox2), swindow);
+ gtk_box_append (GTK_BOX (vbox2), swindow);
/* Drag and Drop */
GDK_ACTION_MOVE);
gdk_content_formats_unref (targets);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+ gtk_box_append (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_button_new_with_mnemonic ("_Add new Column");
g_signal_connect (button, "clicked", G_CALLBACK (add_clicked), left_tree_model);
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
gtk_widget_show (window);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), BORDER_EXPAND);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), ALL_EXPAND);
- gtk_container_add (GTK_CONTAINER (vbox), combo_box);
+ gtk_box_append (GTK_BOX (vbox), combo_box);
/* Scrolled window and tree view */
sw = gtk_scrolled_window_new (NULL, NULL);
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (sw, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), sw);
+ gtk_box_append (GTK_BOX (vbox), sw);
tree_view = gtk_tree_view_new_with_model (create_model ());
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), tree_view);
button = gtk_toggle_button_new_with_label ("Toggle long content row");
g_signal_connect (button, "toggled",
G_CALLBACK (toggle_long_content_row), tree_view);
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
/* Set up option menu callback and default item */
g_signal_connect (combo_box, "changed",
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_window_set_child (GTK_WINDOW (window), box);
- gtk_container_add (GTK_CONTAINER (box), get_dragsource ());
- gtk_container_add (GTK_CONTAINER (box), get_droptarget ());
+ gtk_box_append (GTK_BOX (box), get_dragsource ());
+ gtk_box_append (GTK_BOX (box), get_droptarget ());
gtk_widget_show (window);
checkbutton = gtk_check_button_new_with_label (name);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton), cntl == CNTL_FIXED);
- gtk_container_add (GTK_CONTAINER (box), checkbutton);
+ gtk_box_append (GTK_BOX (box), checkbutton);
g_signal_connect (G_OBJECT (checkbutton), "toggled", callback, data);
g_free (name);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (scrolled_window, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), scrolled_window);
+ gtk_box_append (GTK_BOX (vbox), scrolled_window);
tree_model = create_model ();
tree_view = gtk_tree_view_new_with_model (tree_model);
800, 250);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
/* Alignment controls */
cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
- gtk_container_add (GTK_CONTAINER (hbox), cntl_vbox);
+ gtk_box_append (GTK_BOX (hbox), cntl_vbox);
create_control (cntl_vbox, 1, CNTL_ALIGN, &callback[0]);
create_control (cntl_vbox, 2, CNTL_ALIGN, &callback[1]);
/* Expand controls */
cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
- gtk_container_add (GTK_CONTAINER (hbox), cntl_vbox);
+ gtk_box_append (GTK_BOX (hbox), cntl_vbox);
create_control (cntl_vbox, 1, CNTL_EXPAND, &callback[0]);
create_control (cntl_vbox, 2, CNTL_EXPAND, &callback[1]);
/* Fixed controls */
cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
- gtk_container_add (GTK_CONTAINER (hbox), cntl_vbox);
+ gtk_box_append (GTK_BOX (hbox), cntl_vbox);
create_control (cntl_vbox, 1, CNTL_FIXED, &callback[0]);
create_control (cntl_vbox, 2, CNTL_FIXED, &callback[1]);
gtk_window_set_title (GTK_WINDOW (window), "Reflow test");
g_signal_connect (window, "destroy", G_CALLBACK (quit_cb), &done);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("Incremental Reflow Test"));
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new ("Incremental Reflow Test"));
gtk_window_set_child (GTK_WINDOW (window), vbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (scrolled_window, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), scrolled_window);
+ gtk_box_append (GTK_BOX (vbox), scrolled_window);
initialize_model ();
tree_view = gtk_tree_view_new_with_model (model);
NULL);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled_window), tree_view);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_button_new_with_mnemonic ("<b>_Futz!!</b>");
- gtk_container_add (GTK_CONTAINER (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), button);
gtk_label_set_use_markup (GTK_LABEL (gtk_button_get_child (GTK_BUTTON (button))), TRUE);
g_signal_connect (button, "clicked", G_CALLBACK (futz), NULL);
g_signal_connect (button, "realize", G_CALLBACK (gtk_widget_grab_focus), NULL);
gtk_window_set_title (GTK_WINDOW (window), "Card planning sheet");
g_signal_connect (window, "destroy", G_CALLBACK (quit_cb), &done);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("Jonathan's Holiday Card Planning Sheet"));
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new ("Jonathan's Holiday Card Planning Sheet"));
gtk_window_set_child (GTK_WINDOW (window), vbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (scrolled_window), TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (scrolled_window, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), scrolled_window);
+ gtk_box_append (GTK_BOX (vbox), scrolled_window);
model = make_model ();
tree_view = gtk_tree_view_new_with_model (model);
gtk_window_set_title (GTK_WINDOW (window), "Model");
g_signal_connect (window, "destroy", G_CALLBACK (quit_cb), &done);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("The model revealed"));
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new ("The model revealed"));
gtk_window_set_child (GTK_WINDOW (window), vbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (scrolled_window), TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (scrolled_window, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), scrolled_window);
+ gtk_box_append (GTK_BOX (vbox), scrolled_window);
tree_view = gtk_tree_view_new_with_model (model);
{
child = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_size_request (child, 16 * depth, 0);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
}
if (gtk_tree_list_row_is_expandable (item))
gtk_button_set_has_frame (GTK_BUTTON (title), FALSE);
g_object_bind_property (item, "expanded", title, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
g_object_set_data_full (G_OBJECT (title), "make-sure-its-not-unreffed", g_object_ref (item), g_object_unref);
- gtk_container_add (GTK_CONTAINER (child), title);
+ gtk_box_append (GTK_BOX (child), title);
arrow = g_object_new (GTK_TYPE_SPINNER, "css-name", "arrow", NULL);
gtk_button_set_child (GTK_BUTTON (title), arrow);
{
child = gtk_image_new (); /* empty whatever */
}
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
info = gtk_tree_list_row_get_item (item);
if (icon)
{
child = gtk_image_new_from_gicon (icon);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
}
file = g_object_get_data (G_OBJECT (info), "file");
child = gtk_label_new (g_file_get_basename (file));
g_object_unref (info);
- gtk_container_add (GTK_CONTAINER (box), child);
+ gtk_box_append (GTK_BOX (box), child);
return row;
}
gtk_window_set_child (GTK_WINDOW (win), vbox);
search_entry = gtk_search_entry_new ();
- gtk_container_add (GTK_CONTAINER (vbox), search_entry);
+ gtk_box_append (GTK_BOX (vbox), search_entry);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_search_entry_set_key_capture_widget (GTK_SEARCH_ENTRY (search_entry), hbox);
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
+ gtk_box_append (GTK_BOX (vbox), hbox);
listbox = gtk_list_box_new ();
gtk_widget_set_hexpand (listbox, TRUE);
- gtk_container_add (GTK_CONTAINER (hbox), listbox);
+ gtk_box_append (GTK_BOX (hbox), listbox);
if (argc > 1)
root = g_file_new_for_commandline_arg (argv[1]);
g_signal_connect (filter, "items-changed", G_CALLBACK (update_adjustment), adjustment);
scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment);
- gtk_container_add (GTK_CONTAINER (hbox), scrollbar);
+ gtk_box_append (GTK_BOX (hbox), scrollbar);
statusbar = gtk_statusbar_new ();
gtk_widget_add_tick_callback (statusbar, (GtkTickCallback) update_statusbar, NULL, NULL);
g_object_set_data (G_OBJECT (statusbar), "model", filter);
g_signal_connect_swapped (filter, "items-changed", G_CALLBACK (update_statusbar), statusbar);
update_statusbar (GTK_STATUSBAR (statusbar));
- gtk_container_add (GTK_CONTAINER (vbox), statusbar);
+ gtk_box_append (GTK_BOX (vbox), statusbar);
g_object_unref (tree);
g_object_unref (filter);
gtk_window_set_title (GTK_WINDOW (window), "Words, words, words - Window 1");
g_signal_connect (window, "destroy", G_CALLBACK (quit_cb), &done);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("Jonathan and Kristian's list of cool words. (And Anders' cool list of numbers) \n\nThis is just a GtkTreeStore"));
+ gtk_box_append (GTK_BOX (vbox), gtk_label_new ("Jonathan and Kristian's list of cool words. (And Anders' cool list of numbers) \n\nThis is just a GtkTreeStore"));
gtk_window_set_child (GTK_WINDOW (window), vbox);
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (vbox), entry);
+ gtk_box_append (GTK_BOX (vbox), entry);
button = gtk_button_new_with_label ("Switch search method");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (scrolled_window), TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (scrolled_window, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), scrolled_window);
+ gtk_box_append (GTK_BOX (vbox), scrolled_window);
model = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
"Words, words, words - window 2");
g_signal_connect (window2, "destroy", G_CALLBACK (quit_cb), &done);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox2),
+ gtk_box_append (GTK_BOX (vbox2),
gtk_label_new ("Jonathan and Kristian's list of words.\n\nA GtkTreeModelSort wrapping the GtkTreeStore of window 1"));
gtk_window_set_child (GTK_WINDOW (window2), vbox2);
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (scrolled_window2, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox2), scrolled_window2);
+ gtk_box_append (GTK_BOX (vbox2), scrolled_window2);
tree_view2 = gtk_tree_view_new_with_model (smodel);
"Words, words, words - Window 3");
g_signal_connect (window3, "destroy", G_CALLBACK (quit_cb), &done);
vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
- gtk_container_add (GTK_CONTAINER (vbox3),
+ gtk_box_append (GTK_BOX (vbox3),
gtk_label_new ("Jonathan and Kristian's list of words.\n\nA GtkTreeModelSort wrapping the GtkTreeModelSort of window 2"));
gtk_window_set_child (GTK_WINDOW (window3), vbox3);
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_vexpand (scrolled_window3, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox3), scrolled_window3);
+ gtk_box_append (GTK_BOX (vbox3), scrolled_window3);
tree_view3 = gtk_tree_view_new_with_model (ssmodel);
for (i = 0; i < MODEL_LAST; i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), model_names[i]);
- gtk_container_add (GTK_CONTAINER (box), combo_box);
+ gtk_box_append (GTK_BOX (box), combo_box);
g_signal_connect (combo_box,
"changed",
G_CALLBACK (model_selected),
for (i = 0; i < COLUMNS_LAST; i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), column_type_names[i]);
- gtk_container_add (GTK_CONTAINER (box), combo_box);
+ gtk_box_append (GTK_BOX (box), combo_box);
set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), COLUMNS_LOTS);
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (box), sw);
+ gtk_box_append (GTK_BOX (box), sw);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), tv);
NULL);
gtk_window_set_child (GTK_WINDOW (window), vbox);
- gtk_container_add (GTK_CONTAINER (vbox), box);
- gtk_container_add (GTK_CONTAINER (box), button);
- gtk_container_add (GTK_CONTAINER (box), button2);
+ gtk_box_append (GTK_BOX (vbox), box);
+ gtk_box_append (GTK_BOX (box), button);
+ gtk_box_append (GTK_BOX (box), button2);
gtk_widget_show (window);
g_timeout_add (4000, (GSourceFunc) show_error, window);
gtk_button_set_label (GTK_BUTTON (toggle_button), "Picking");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_button), do_picking);
g_signal_connect (toggle_button, "toggled", G_CALLBACK (toggled_cb), NULL);
- gtk_container_add (GTK_CONTAINER (titlebar), toggle_button);
+ gtk_box_append (GTK_BOX (titlebar), toggle_button);
test_widget = gtk_button_new ();
gtk_widget_set_size_request (test_widget, TEST_WIDGET_MIN_SIZE, TEST_WIDGET_MIN_SIZE);
gtk_widget_set_halign (test_child, GTK_ALIGN_CENTER);
gtk_widget_set_valign (test_child, GTK_ALIGN_CENTER);
gtk_widget_set_size_request (test_child, TEST_WIDGET_MIN_SIZE / 2, TEST_WIDGET_MIN_SIZE / 2);
- gtk_container_add (GTK_CONTAINER (test_widget), test_child);
+ gtk_box_append (GTK_BOX (test_widget), test_child);
gtk_transform_tester_set_test_widget (GTK_TRANSFORM_TESTER (transform_tester), test_widget);
gtk_widget_set_vexpand (transform_tester, TRUE);
- gtk_container_add (GTK_CONTAINER (box), transform_tester);
- gtk_container_add (GTK_CONTAINER (box), matrix_chooser);
+ gtk_box_append (GTK_BOX (box), transform_tester);
+ gtk_box_append (GTK_BOX (box), matrix_chooser);
gtk_window_set_child (GTK_WINDOW (window), box);
gtk_window_set_default_size ((GtkWindow *)window, 200, 200);
gtk_window_set_resizable (GTK_WINDOW (dialog), resizable);
- gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+ gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
label);
label = gtk_label_new ("? x ?");
/* Put them together */
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled_window), tree_view);
gtk_widget_set_vexpand (scrolled_window, TRUE);
- gtk_container_add (GTK_CONTAINER (vbox), scrolled_window);
+ gtk_box_append (GTK_BOX (vbox), scrolled_window);
gtk_window_set_child (GTK_WINDOW (window), vbox);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
/* buttons */
button = gtk_button_new_with_label ("gtk_tree_store_remove");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (selection, "changed",
G_CALLBACK (selection_changed),
button);
button = gtk_button_new_with_label ("gtk_tree_store_insert");
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
- gtk_container_add (GTK_CONTAINER (hbox), button);
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), entry);
g_object_set_data (G_OBJECT (button), "user_data", entry);
g_signal_connect (button, "clicked",
G_CALLBACK (iter_insert),
button = gtk_button_new_with_label ("gtk_tree_store_set");
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
- gtk_container_add (GTK_CONTAINER (hbox), button);
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), entry);
g_object_set_data (G_OBJECT (button), "user_data", entry);
g_signal_connect (button, "clicked",
G_CALLBACK (iter_change),
button = gtk_button_new_with_label ("gtk_tree_store_insert_with_values");
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
entry = gtk_entry_new ();
- gtk_container_add (GTK_CONTAINER (vbox), hbox);
- gtk_container_add (GTK_CONTAINER (hbox), button);
- gtk_container_add (GTK_CONTAINER (hbox), entry);
+ gtk_box_append (GTK_BOX (vbox), hbox);
+ gtk_box_append (GTK_BOX (hbox), button);
+ gtk_box_append (GTK_BOX (hbox), entry);
g_object_set_data (G_OBJECT (button), "user_data", entry);
g_signal_connect (button, "clicked",
G_CALLBACK (iter_insert_with_values),
tree_view);
button = gtk_button_new_with_label ("gtk_tree_store_insert_before");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (iter_insert_before),
tree_view);
gtk_widget_set_sensitive (button, FALSE);
button = gtk_button_new_with_label ("gtk_tree_store_insert_after");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (iter_insert_after),
tree_view);
gtk_widget_set_sensitive (button, FALSE);
button = gtk_button_new_with_label ("gtk_tree_store_prepend");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (iter_prepend),
tree_view);
button = gtk_button_new_with_label ("gtk_tree_store_append");
- gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (button, "clicked",
G_CALLBACK (iter_append),
tree_view);
child = gtk_widget_get_parent (child);
}
- gtk_container_remove (GTK_CONTAINER (state->widget), child);
+ gtk_box_remove (GTK_BOX (state->widget), child);
}
static void
child_accessible = gtk_widget_get_accessible (state.child[i]);
g_signal_connect (child_accessible, "notify::accessible-parent",
G_CALLBACK (parent_notify), &(parent_data[i]));
- gtk_container_add (GTK_CONTAINER (widget), state.child[i]);
+ gtk_box_append (GTK_BOX (widget), state.child[i]);
}
else
child_accessible = atk_object_ref_accessible_child (accessible, i);
button = gtk_button_new ();
gtk_window_set_child (GTK_WINDOW (window), box);
- gtk_container_add (GTK_CONTAINER (box), button);
+ gtk_box_append (GTK_BOX (box), button);
win_actions = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (win_actions),
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
text = gtk_text_new ();
- gtk_container_add (GTK_CONTAINER (box), text);
+ gtk_box_append (GTK_BOX (box), text);
clipboard_actions = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (clipboard_actions),
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_widget_set_vexpand (C, TRUE);
gtk_widget_set_name (C, "C");
- gtk_container_add (GTK_CONTAINER (A), B);
- gtk_container_add (GTK_CONTAINER (B), C);
+ gtk_box_append (GTK_BOX (A), B);
+ gtk_box_append (GTK_BOX (B), C);
gtk_widget_show (A);
gtk_window_set_child (GTK_WINDOW (window), box);
grid = gtk_grid_new ();
- gtk_container_add (GTK_CONTAINER (box), grid);
+ gtk_box_append (GTK_BOX (box), grid);
label = gtk_label_new ("Hello World");
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
assert_model (model, "GtkLabel");
assert_changes (model, "1-3");
- gtk_container_add (GTK_CONTAINER (grandparent), widget);
+ gtk_box_append (GTK_BOX (grandparent), widget);
assert_model (model, "GtkLabel GtkBox GtkWindow");
assert_changes (model, "1+2");
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *l = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (box), l);
+ gtk_box_append (GTK_BOX (box), l);
g_assert (gtk_widget_get_parent (l) == box);
g_assert (gtk_widget_get_prev_sibling (l) == NULL);
GtkWidget *l1 = gtk_label_new ("");
GtkWidget *l2 = gtk_label_new ("");
- gtk_container_add (GTK_CONTAINER (box), l1);
- gtk_container_add (GTK_CONTAINER (box), l2);
+ gtk_box_append (GTK_BOX (box), l1);
+ gtk_box_append (GTK_BOX (box), l2);
g_assert (gtk_widget_get_parent (l1) == box);
g_assert (gtk_widget_get_prev_sibling (l1) == NULL);
projects / gtk4.git / commitdiff